;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:26 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/idlwave.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


(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%\210\340\341\342\343\334\336\344\345&\210\340\346\347\350\334\336\344\345&\210\340\351\352\353\334\336\344\345&\210\340\354\347\355\334\336\344\345&\210\340\356\357\360\334\336\344\345&\210\340\361\362\363\334\336\344\364&\210\340\365\315\366\334\336\344\364&\210\340\367\362\370\334\336\344\364&\210\340\371\372\373\334\336\344\374&\210\340\375\315\376\334\336\344\364&\210\340\377\362\201@\334\336\344\364&\210\340\201A\362\201B\334\336\344\364&\210\340\201C\362\201D\334\336\344\364&\210\340\201E\201F\201G\334\336\344\201H&\210\340\201I\315\201J\334\336\344\201K&\210\340\201L\201M\201N\334\336\344\374&\210\320\201O\315\201P\334\321%\210\340\201Q\362\201R\334\201O\344\364&\210\340\201S\201T\201U\334\201O\344\201V&\210\340\201W\362\201X\334\201O\344\201Y&\210\340\201Z\362\201[\334\201O\344\364&\210\340\201\\\201]\201^\334\201O\344\201_&\210\340\201`\201a\201b\334\201O\344\345&\210\340\201c\315\201d\334\201O\344\201e&\210\340\201f\201g\201h\334\201O\344\201i&\210\340\201j\201k\201l\334\201O\344\201m&\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." custom-declare-variable idlwave-main-block-indent 2 "Extra indentation for the main block of code.\nThat is the block between the FUNCTION/PRO statement and the END\nstatement for that program unit." :type integer idlwave-block-indent 3 "Extra indentation applied to block lines.\nIf you change this, you probably also want to change `idlwave-end-offset'." idlwave-end-offset -3 "Extra indentation applied to block END lines.\nA value equal to negative `idlwave-block-indent' will make END lines\nline up with the block BEGIN lines." idlwave-continuation-indent "Extra indentation applied to continuation lines.\nThis extra offset applies to the first of a set of continuation lines.\nThe following lines receive the same indentation as the first." idlwave-max-extra-continuation-indent 40 "Maximum additional indentation for special continuation indent.\nSeveral special indentations are tried to help line up continuation\nlines in routine calls or definitions, other statements with\nparentheses, or assignment statements.  This variable specifies a\nmaximum amount by which this special indentation can exceed the\nstandard continuation indentation, otherwise defaulting to a fixed\noffset.  Set to 0 to effectively disable all special continuation\nindentation, or to a large number (like 100) to enable it in all\ncases.  See also `idlwave-indent-to-open-paren', which can override\nthis variable." idlwave-indent-to-open-paren t "Non-nil means, indent continuation lines to innermost open parenthesis.\nThis indentation occurs even if otherwise disallowed by\n`idlwave-max-extra-continuation-indent'.  Matching parens and the\ninterleaving args are lined up.  Example:\n\n  x = function_a(function_b(function_c( a, b, [1,2,3, $\n                                               4,5,6 $\n                                              ], $\n                                        c, d $\n                                      )))\n\nWhen this variable is nil, paren alignment may still occur, based on\nthe value of `idlwave-max-extra-continuation-indent', which, if zero,\nwould yield:\n\n  x = function_a(function_b(function_c( a, b, [1,2,3, $\n     4,5,6 $\n     ], $\n     c, d $\n     )))" boolean idlwave-indent-parens-nested "Non-nil means, indent continuation lines with parens by nesting\nlines at consecutively deeper levels." idlwave-hanging-indent "If set non-nil then comment paragraphs are indented under the\nhanging indent given by `idlwave-hang-indent-regexp' match in the first line\nof the paragraph." idlwave-hang-indent-regexp "- " "Regular expression matching the position of the hanging indent\nin the first line of a comment paragraph.  The size of the indent\nextends to the end of the match for the regular expression." regexp idlwave-use-last-hang-indent "If non-nil then use last match on line for `idlwave-indent-regexp'." idlwave-fill-comment-line-only "If non-nil then auto fill will only operate on comment lines." idlwave-auto-fill-split-string "If non-nil then auto fill will split strings with the IDL `+' operator.\nWhen the line end falls within a string, string concatenation with the\n'+' operator will be used to distribute a long string over lines.\nIf nil and a string is split then a terminal beep and warning are issued.\n\nThis variable is ignored when `idlwave-fill-comment-line-only' is\nnon-nil, since in this case code is not auto-filled." idlwave-split-line-string "If non-nil then `idlwave-split-line' will split strings with `+'.\nWhen the splitting point of a line falls inside a string, split the string\nusing the `+' string concatenation operator.  If nil and a string is\nsplit then a terminal beep and warning are issued." idlwave-no-change-comment ";;;" "The indentation of a comment that starts with this regular\nexpression will not be changed.  Note that the indentation of a comment\nat the beginning of a line is never changed." string idlwave-begin-line-comment "A comment anchored at the beginning of line.\nA comment matching this regular expression will not have its\nindentation changed.  If nil the default is \"^;\", i.e., any line\nbeginning with a \";\".  Expressions for comments at the beginning of\nthe line should begin with \"^\"." (choice (const :tag "Any line beginning with `;'" nil) 'regexp) idlwave-code-comment ";;[^;]" "A comment that starts with this regular expression on a line by\nitself is indented as if it is a part of IDL code.  As a result if\nthe comment is not preceded by whitespace it is unchanged." idlwave-routine-info "Routine Info options for IDLWAVE mode." idlwave-use-library-catalogs "Non-nil means search the IDL path for library catalog files.\n\nThese files, named .idlwave_catalog, document routine information for\nindividual directories and libraries of IDL .pro files.  Many popular\nlibraries come with catalog files by default, so leaving this on is\nusually a good idea." idlwave-init-rinfo-when-idle-after 10 "Seconds of idle time before routine info is automatically initialized.\nInitializing the routine info can take a long time, in particular if a\nlarge number of library catalogs are involved.  When Emacs is idle for\nmore than the number of seconds specified by this variable, it starts\nthe initialization.  The process is split into five steps, in order to\nkeep work interruption as short as possible.  If one of the steps\nfinishes, and no user input has arrived in the mean time, initialization\nproceeds immediately to the next step.  A good value for this variable\nis about 1/3 of the time initialization take in your setup.  So if you\nhave a fast machine and no problems with a slow network connection,\ndon't hesitate to set this to 2 seconds.  A value of 0 means, don't\ninitialize automatically, but instead wait until routine information is\nneeded, and initialize then." number idlwave-scan-all-buffers-for-routine-info "Non-nil means, scan buffers for IDL programs when updating info.\nThe scanning is done by the command `idlwave-update-routine-info'.\nThe following values are allowed:\n\nnil       Don't scan any buffers.\nt         Scan all `idlwave-mode' buffers in the current editing session.\ncurrent   Scan only the current buffer, but no other buffers." (choice (const :tag "No buffer" nil) (const :tag "All buffers" t) (const :tag "Current buffer only" 'current)) idlwave-query-shell-for-routine-info "Non-nil means query the shell for info about compiled routines.\nQuerying the shell is useful to get information about compiled modules,\nand it is turned on by default.  However, when you have a complete library\nscan, this is not necessary." idlwave-auto-routine-info-updates '(find-file save-buffer kill-buffer compile-buffer) "Controls under what circumstances routine info is updated automatically.\nPossible values:\nnil       Never\nt         All available\n(...)     A list of circumstances.  Allowed members are:\n           find-file       Add info for new IDLWAVE buffers.\n           save-buffer     Update buffer info when buffer is saved\n           kill-buffer     Remove buffer info when buffer gets killed\n           compile-buffer  Update shell info after `idlwave-shell-save-and...'" (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))) idlwave-rinfo-max-source-lines 5 "Maximum number of source files displayed in the Routine Info window.\nWhen an integer, it is the maximum number of source files displayed.\nA value of t means to show all source files." idlwave-library-path "Library path for Windows and MacOS (OS9).  Not needed under UNIX.\nWhen selecting the directories to scan for IDL user catalog routine\ninfo, IDLWAVE can, under UNIX, query the shell for the exact search\npath (the value of !PATH).  However, under Windows and MacOS\n(pre-OSX), the IDLWAVE shell does not work.  In this case, this\nvariable can be set to specify the paths where IDLWAVE can find PRO\nfiles.  The shell will only be asked for a list of paths when this\nvariable is nil.  The value is a list of directories.  A directory\npreceded by a `+' will be searched recursively.  If you set this\nvariable on a UNIX system, the shell will not be queried.  See also\n`idlwave-system-directory'." (repeat (directory)) idlwave-system-directory "" "The IDL system directory for Windows and MacOS.  Not needed under\nUNIX.  Set this to the value of the `!DIR' system variable in IDL.\nIDLWAVE uses this to find out which of the library routines belong to\nthe official system library.  All files inside the `lib' subdirectory\nare considered system library files - so don't install private stuff\nin this directory.  On UNIX systems, IDLWAVE queries the shell for the\nvalue of `!DIR'.  See also `idlwave-library-path'." directory idlwave-config-directory (convert-standard-filename "~/.idlwave") "Directory for configuration files and user-library catalog." file] 18)
(defvar idlwave-user-catalog-file "idlusercat.el")
(defvar idlwave-xml-system-rinfo-converted-file "idl_xml_rinfo.el")
(defvar idlwave-path-file "idlpath.el")
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\313&\210\314\315\302\316\317\320\304\321&\207" [custom-declare-variable idlwave-special-lib-alist nil "Alist of regular expressions matching special library directories.\nWhen listing routine source locations, IDLWAVE gives a short hint where\nthe file defining the routine is located.  By default it lists `SystemLib'\nfor routines in the system library `!DIR/lib' and `Library' for anything\nelse.  This variable can define additional types.  The car of each entry\nis a regular expression matching the file name (they normally will match\non the path).  The cdr is the string to be used as identifier.  Max 10\nchars are allowed." :group idlwave-routine-info :type (repeat (cons regexp string)) idlwave-auto-write-paths t "Write out path (!PATH) and system directory (!DIR) info automatically.\nPath info is needed to locate library catalog files.  If non-nil,\nwhenever the path-list changes as a result of shell-query, etc., it is\nwritten to file.  Otherwise, the menu option \"Write Paths\" can be\nused to force a write." boolean custom-declare-group idlwave-completion "Completion options for IDLWAVE mode." :prefix "idlwave" idlwave] 8)
(defconst idlwave-tmp '(choice :tag "by applying the function" (const upcase) (const downcase) (const capitalize) (const preserve) (symbol :tag "Other")))
(byte-code "\301\302\303\304\305\306\307\310\311\312ED&\210\301\313\314\315\305\306\307\316&\210\301\317\314\320\305\306\307\316&\210\301\321\314\322\305\306\307\316&\210\301\323\324\325\305\306\307\316&\210\301\326\324\327\305\330\307\316&\210\301\331\332\333\305\330\307\334&\210\301\335\336\337\305\306\307\340&\210\301\341\324\342\305\306\307\316&\210\301\343\344\345\305\306\307\346&\210\301\347\324\350\305\306\307\316&\210\301\351\352\353\305\306\307\354&\210\301\355\324\356\305\306\307\316&\210\301\357\324\360\305\306\307\316&\210\301\361\324\362\305\306\307\363&\210\301\364\324\365\305\306\307\316&\210\366\367\314\370\305\371%\210\301\372\314\373\305\367\307\316&\210\301\374\375\376\305\367\307\377&\210\301\201@\314\201A\305\367\307\316&\210\301\201B\324\201C\305\367\307\201D&\210\301\201E\324\201F\305\367\307\316&\210\301\201G\314\201H\305\367\307\316&\210\301\201I\324\201J\305\367\307\316&\210\301\201K\324\201L\305\367\307\316&\210\301\201M\314\201N\305\367\307\316&\210\301\201O\314\201P\305\367\307\316&\207" [idlwave-tmp custom-declare-variable idlwave-completion-case '((routine . upcase) (keyword . upcase) (class . preserve) (method . preserve)) "Association list setting the case of completed words.\n\nThis variable determines the case (UPPER/lower/Capitalized...) of\nwords inserted into the buffer by completion.  The preferred case can\nbe specified separately for routine names, keywords, classes and\nmethods.\nThis alist should therefore have entries for `routine' (normal\nfunctions and procedures, i.e. non-methods), `keyword', `class', and\n`method'.  Plausible values are\n\nupcase      upcase whole word, like `BOX_CURSOR'\ndowncase    downcase whole word, like `read_ppm'\ncapitalize  capitalize each part, like `Widget_Control'\npreserve    preserve case as is, like `IDLgrView'\n\nThe value can also be any Emacs Lisp function which transforms the\ncase of characters in a string.\n\nA value of `preserve' means that the case of the completed word is\nidentical to the way it was written in the definition statement of the\nroutine.  This was implemented to allow for mixed-case completion, in\nparticular of object classes and methods.\nIf a completable word is defined in multiple locations, the meaning of\n`preserve' is not unique since the different definitions might be\ncased differently.  Therefore IDLWAVE always takes the case of the\n*first* definition it encounters during routine info collection and\nuses the case derived from it consistently.\n\nNote that a lowercase-only string in the buffer will always be completed in\nlower case (but see the variable `idlwave-completion-force-default-case').\n\nAfter changing this variable, you need to either restart Emacs or press\n`C-u C-c C-i' to update the internal lists." :group idlwave-completion :type repeat cons (symbol :tag "Derive completion case for") idlwave-completion-force-default-case nil "Non-nil means, completion will always honor `idlwave-completion-case'.\nWhen nil, only the completion of a mixed case or upper case string\nwill honor the default settings in `idlwave-completion-case', while\nthe completion of lower case strings will be completed entirely in\nlower case." boolean idlwave-complete-empty-string-as-lower-case "Non-nil means, the empty string is considered downcase for completion.\nThe case of what is already in the buffer determines the case of completions.\nWhen this variable is non-nil, the empty string is considered to be downcase.\nCompleting on the empty string then offers downcase versions of the possible\ncompletions." idlwave-buffer-case-takes-precedence "Non-nil means, the case of tokens in buffers dominates over system stuff.\nTo make this possible, we need to re-case everything each time we update\nthe routine info from the buffers.  This is slow.\nThe default is to consider the case given in the system and library files\nfirst which makes updating much faster." idlwave-highlight-help-links-in-completion t "Non-nil means, highlight completions for which system help is available.\nHelp can then be accessed with mouse-3.\nThis option is only effective when the online help system is installed." idlwave-support-inheritance "Non-nil means, treat inheritance with completion, online help etc.\nWhen nil, IDLWAVE only knows about the native methods and tags of a class,\nnot about inherited ones." idlwave-routine-info idlwave-keyword-class-inheritance '("^[gs]etproperty$" "^init$") "List of regular expressions for class-driven keyword inheritance.\nKeyword inheritance is often tied to class inheritance by \"chaining\"\nup the class tree.  While it cannot be assumed that the presence of an\n_EXTRA or _REF_EXTRA symbol guarantees such chaining will occur, for\ncertain methods this assumption is almost always true.  The methods\nfor which to assume this can be set here." (repeat (regexp :tag "Match method:")) idlwave-completion-show-classes 1 "Number of classes to show when completing object methods and keywords.\nWhen completing methods or keywords for an object with unknown class,\nthe *Completions* buffer will show the valid classes for each completion\nlike this:\n\nMyMethod <Class1,Class2,Class3>\n\nThe value of this variable may be nil to inhibit display, or an integer to\nindicate the maximum number of classes to display.\n\nOn XEmacs, a full list of classes will also be placed into a `help-echo'\nproperty on the completion items, so that the list of classes for the current\nitem is displayed in the echo area.  If the value of this variable is a\nnegative integer, the `help-echo' property will be suppressed." (choice (const :tag "Don't show" nil) (integer :tag "Number of classes shown" 1)) idlwave-completion-fontify-classes "Non-nil means, fontify the classes in completions buffer.\nThis makes it easier to distinguish the completion items from the extra\nclass info listed.  See `idlwave-completion-show-classes'." idlwave-query-class '((method-default) (keyword-default)) "Association list governing specification of object classes for completion.\n\nWhen IDLWAVE tries to complete object-oriented methods, it usually\ncannot determine the class of a given object from context.  In order\nto provide the user with a correct list of methods or keywords, it\nneeds to determine the appropriate class.  IDLWAVE has two ways of\ndoing this (well, three ways if you count the shell... see\n`idlwave-shell-query-for-class'):\n\n1. Combine the items of all available classes which contain this\n   method for the purpose of completion.  So when completing a method,\n   all methods of all known classes are available, and when completing\n   a keyword, all keywords allowed for this method in any class are\n   shown.  This behavior is very much like normal completion and is\n   therefore the default.  It works much better than one might think -\n   only for the INIT, GETPROPERTY and SETPROPERTY the keyword lists\n   become uncomfortably long.  See also\n   `idlwave-completion-show-classes'.\n\n2. The second possibility is to ask the user on each occasion.  To\n   make this less interruptive, IDLWAVE can store the class as a text\n   property on the object operator `->'.  For a given object in the\n   source code, class selection will then be needed only once\n   - for example to complete the method.  Keywords to the method can\n   then be completed directly, because the class is already known.\n   You will have to turn on the storage of the selected class\n   explicitly with the variable `idlwave-store-inquired-class'.\n\nThis variable allows you to configure IDLWAVE's method and\nmethod-keyword completion behavior.  Its value is an alist, which\nshould contain at least two elements: (method-default . VALUE) and\n(keyword-default . VALUE), where VALUE is either t or nil.  These\nspecify if the class should be found during method and keyword\ncompletion, respectively.\n\nThe alist may have additional entries specifying exceptions from the\nkeyword completion rule for specific methods, like INIT or\nGETPROPERTY.  In order to turn on class specification for the INIT\nmethod, add an entry (\"INIT\" . t).  The method name must be ALL-CAPS." (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")))) idlwave-store-inquired-class "Non-nil means, store class of a method call as text property on `->'.\nIDLWAVE sometimes has to ask the user for the class associated with a\nparticular object method call.  This happens during the commands\n`idlwave-routine-info' and `idlwave-complete', depending upon the\nvalue of the variable `idlwave-query-class'.\n\nWhen you specify a class, this information can be stored as a text\nproperty on the `->' arrow in the source code, so that during the same\nediting session, IDLWAVE will not have to ask again.  When this\nvariable is non-nil, IDLWAVE will store and reuse the class information.\nThe class stored can be checked and removed with `\\[idlwave-routine-info]'\non the arrow.\n\nThe default of this variable is nil, since the result of commands then\nis more predictable.  However, if you know what you are doing, it can\nbe nice to turn this on.\n\nAn arrow which knows the class will be highlighted with\n`idlwave-class-arrow-face'.  The command \\[idlwave-routine-info]\ndisplays (with prefix arg: deletes) the class stored on the arrow\nat point." idlwave-class-arrow-face 'bold "Face to highlight object operator arrows `->' which carry a class property.\nWhen IDLWAVE stores a class name as text property on an object arrow\n(see variable `idlwave-store-inquired-class', it highlights the arrow\nwith this font in order to remind the user that this arrow is special." symbol idlwave-resize-routine-help-window "Non-nil means, resize the Routine-info *Help* window to fit the content." idlwave-keyword-completion-adds-equal "Non-nil means, completion automatically adds `=' after completed keywords." idlwave-function-completion-adds-paren "Non-nil means, completion automatically adds `(' after completed function.\nnil means, don't add anything.\nA value of `2' means, also add the closing parenthesis and position cursor\nbetween the two." (choice (const :tag "Nothing" nil) (const :tag "(" t) (const :tag "()" 2)) idlwave-completion-restore-window-configuration "Non-nil means, try to restore the window configuration after completion.\nWhen completion is not unique, Emacs displays a list of completions.\nThis messes up your window configuration.  With this variable set, IDLWAVE\nrestores the old configuration after successful completion." custom-declare-group idlwave-abbrev-and-indent-action "IDLWAVE performs actions when expanding abbreviations or indenting lines.\nThe variables in this group govern this." idlwave idlwave-do-actions "Non-nil means performs actions when indenting.\nThe actions that can be performed are listed in `idlwave-indent-action-table'." idlwave-abbrev-start-char "\\" "A single character string used to start abbreviations in abbrev mode.\nPossible characters to chose from: ~`%\nor even '?'.  '.' is not a good choice because it can make structure\nfield names act like abbrevs in certain circumstances.\n\nChanges to this in `idlwave-mode-hook' will have no effect.  Instead a user\nmust set it directly using `setq' in the init file before idlwave.el\nis loaded." string idlwave-surround-by-blank "Non-nil means, enable `idlwave-surround'.\nIf non-nil, `=',`<',`>',`&',`,', `->' are surrounded with spaces by\n`idlwave-surround'.\nSee help for `idlwave-indent-action-table' for symbols using `idlwave-surround'.\n\nAlso see the default key bindings for keys using `idlwave-surround'.\nKeys are bound and made into actions calling `idlwave-surround' with\n`idlwave-action-and-binding'.\nSee help for `idlwave-action-and-binding' for examples.\n\nAlso see help for `idlwave-surround'." idlwave-pad-keyword "Non-nil means pad '=' in keywords (routine calls or defs) like assignment.\nWhenever `idlwave-surround' is non-nil then this affects how '=' is\npadded for keywords and for variables.  If t, pad the same as for\nassignments.  If nil then spaces are removed.  With any other value,\nspaces are left unchanged." (choice (const :tag "Pad like assignments" t) (const :tag "Remove space near `='" nil) (const :tag "Keep space near `='" 'keep)) idlwave-show-block "Non-nil means point blinks to block beginning for `idlwave-show-begin'." idlwave-expand-generic-end "Non-nil means expand generic END to ENDIF/ENDELSE/ENDWHILE etc." idlwave-reindent-end "Non-nil means re-indent line after END was typed." idlwave-abbrev-move "Non-nil means the abbrev hook can move point.\nSet to nil by `idlwave-expand-region-abbrevs'.  To see the abbrev\ndefinitions, use the command `list-abbrevs', for abbrevs that move\npoint.  Moving point is useful, for example, to place point between\nparentheses of expanded functions.\n\nSee `idlwave-check-abbrev'." idlwave-abbrev-change-case "Non-nil means all abbrevs will be forced to either upper or lower case.\nIf the value t, all expanded abbrevs will be upper case.\nIf the value is 'down then abbrevs will be forced to lower case.\nIf nil, the case will not change.\nIf `idlwave-reserved-word-upcase' is non-nil, reserved words will always be\nupper case, regardless of this variable." idlwave-reserved-word-upcase "Non-nil means, reserved words will be made upper case via abbrev expansion.\nIf nil case of reserved words is controlled by `idlwave-abbrev-change-case'.\nHas effect only if in abbrev-mode."] 11)
#@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 (#$ . 27047))
#@395 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 (#$ . 27487))
(custom-declare-group 'idlwave-documentation nil "Options for documenting IDLWAVE files." :group 'idlwave)
#@329 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") (#$ . 28049))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\313&\210\300\314\315\316\304\305\306\317&\210\300\320\321\322\304\305\306\323&\210\300\324\325\326\304\305\306\323&\210\327\330\331\332\304\333%\210\300\334\335\336\304\330\306\317&\210\300\337\331\340\306\341\304\330&\210\300\342\343\344\304\330\306\317&\210\300\345\346\347\304\350\306\351&\210\300\352\331\353\304\350\306\307&\210\327\354\331\355\356\357\304\333&\210\300\360\302\361\304\354\306\307&\210\300\362\363\364\304\354\306\365&\210\300\366\331\367\304\354\306\370&\210\300\371\331\372\304\354\306\370&\207" [custom-declare-variable idlwave-header-to-beginning-of-file t "Non-nil means, the documentation header will always be at start of file.\nWhen nil, the header is positioned between the PRO/FUNCTION line of\nthe current routine and the code, allowing several routine headers in\na file." :group idlwave-documentation :type boolean idlwave-timestamp-hook 'idlwave-default-insert-timestamp "The hook function used to update the timestamp of a function." function idlwave-doc-modifications-keyword "HISTORY" "The modifications keyword to use with the log documentation commands.\nA ':' is added to the keyword end.\nInserted by doc-header and used to position logs by doc-modification.\nIf nil it will not be inserted." string idlwave-doclib-start "^;+\\+" "Regexp matching the start of a document library header." regexp idlwave-doclib-end "^;+-" "Regexp matching the end of a document library header." custom-declare-group idlwave-external-programs nil "Path locations of external commands used by IDLWAVE." idlwave idlwave-shell-explicit-file-name "idl" "If non-nil, this is the command to run IDL.\nShould be an absolute file path or path relative to the current environment\nexecution search path.  If you want to specify command line switches\nfor the IDL program, use `idlwave-shell-command-line-options'.\n\nI know the name of this variable is badly chosen, but I cannot change\nit without compromising backwards-compatibility." idlwave-shell-command-line-options "A list of command line options for calling the IDL program.\nSince IDL is executed directly without going through a shell like /bin/sh,\nthis should be a list of strings like '(\"-rt=file\" \"-nw\") with a separate\nstring for each argument.  But you may also give a single string which\ncontains the options whitespace-separated.  Emacs will be kind enough to\nsplit it for you." (choice string (repeat (string :value ""))) idlwave-help-application "idlhelp" "The external application providing reference help for programming.\nObsolete, if the IDL Assistant is being used for help." idlwave-shell-debug-modifiers 'nil "List of modifiers to be used for the debugging commands.\nWill be used to bind debugging commands in the shell buffer and in all\nsource buffers.  These are additional convenience bindings, the debugging\ncommands are always available with the `C-c C-d' prefix.\nIf you set this to '(control shift), this means setting a breakpoint will\nbe on `C-S-b', compiling a source file on `C-S-c' etc.  Possible modifiers\nare `control', `meta', `super', `hyper', `alt', and `shift'." idlwave-shell-general-setup (set :tag "Specify modifiers" (const control) (const meta) (const super) (const hyper) (const alt) (const shift)) idlwave-shell-automatic-start "If non-nil attempt invoke `idlwave-shell' if not already running.\nThis is checked when an attempt to send a command to an\nIDL process is made." idlwave-misc "Miscellaneous options for IDLWAVE mode." :link (custom-group-link :tag "Font Lock Faces group" font-lock-faces) idlwave-startup-message "Non-nil displays a startup message when `idlwave-mode' is first called." idlwave-default-font-lock-items '(pros-and-functions batch-files idlwave-idl-keywords label goto common-blocks class-arrows) "Items which should be fontified on the default fontification level 2.\nIDLWAVE defines 3 levels of fontification.  Level 1 is very little, level 3\nis everything and level 2 is specified by this list.\nThis variable must be set before IDLWAVE gets loaded.\nIt is a list of symbols; the following symbols are allowed:\n\npros-and-functions   Procedure and Function definitions\nbatch-files          Batch Files\nidlwave-idl-keywords IDL Keywords\nlabel                Statement Labels\ngoto                 Goto Statements\ncommon-blocks        Common Blocks\nkeyword-parameters   Keyword Parameters in routine definitions and calls\nsystem-variables     System Variables\nfixme                FIXME: Warning in comments (on XEmacs only v. 21.0 and up)\nclass-arrows         Object Arrows with class property" (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)) idlwave-mode-hook "Normal hook.  Executed when a buffer is put into `idlwave-mode'." hook idlwave-load-hook "Normal hook.  Executed when idlwave.el is loaded."] 8)
#@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 (#$ . 34256))
(defvar idlwave-idl-keywords "\\<\\(&&\\|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\\|||\\)\\>")
(byte-code "\306\307\310\311\312\313\314\315\316\317\320\321\nD!\210\322\323\324\"!\210\325\n\f
	\257!\210.\323\207" [pros-and-functions common-blocks batch-files fixme label goto ("\\<\\(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-constant-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-constant-face)) ("\\(goto\\)[ 	]*,[ 	]*\\([a-zA-Z]\\sw*\\)" (1 font-lock-keyword-face) (2 font-lock-constant-face)) ("\\<\\([a-zA-Z][a-zA-Z0-9_]*:\\)[^:]" (1 font-lock-constant-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-constant-face)) ("\\(![a-zA-Z_0-9]+\\(\\.\\sw+\\)?\\)" (1 font-lock-variable-name-face)) (idlwave-match-class-arrows (0 idlwave-class-arrow-face)) (lambda (#1=#:def-tmp-var) (defconst idlwave-font-lock-keywords-1 #1# "Subdued level highlighting for IDLWAVE mode.")) (lambda (#1#) (defconst idlwave-font-lock-keywords-2 #1# "Medium level highlighting for IDLWAVE mode.")) mapcar symbol-value (lambda (#1#) (defconst idlwave-font-lock-keywords-3 #1# "Gaudy level highlighting for IDLWAVE mode.")) structtag structname keyword-parameters system-variables class-arrows idlwave-default-font-lock-items idlwave-idl-keywords] 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 (#$ . 36835))
(defvar idlwave-font-lock-defaults '((idlwave-font-lock-keywords idlwave-font-lock-keywords-1 idlwave-font-lock-keywords-2 idlwave-font-lock-keywords-3) nil t ((36 . "w") (95 . "w") (46 . "w") (124 . "w") (38 . "w")) beginning-of-line))
(put 'idlwave-mode 'font-lock-defaults idlwave-font-lock-defaults)
#@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 "^[ 	]*;" (#$ . 37274))
#@119 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\\)\\>" (#$ . 37495))
#@79 Regular expression to find the beginning of a unit.
The case does not matter.
(defconst idlwave-begin-unit-reg "^\\s-*\\(pro\\|function\\)\\>\\|\\`" (#$ . 37720))
#@195 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\\)\\>\\|\\'" (#$ . 37890))
#@47 Regular expression to match a continued line.
(defconst idlwave-continue-line-reg "\\<\\$" (#$ . 38173))
#@113 Regular expression to find the end of a block.
The case does not matter.  The search skips matches in comments.
(defconst idlwave-end-block-reg "\\<end\\(\\|case\\|switch\\|else\\|for\\|if\\|rep\\|while\\)\\>" (#$ . 38285))
#@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")) (#$ . 38516))
#@168 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\\)\\>" (#$ . 39131))
#@48 Regular expression matching an IDL identifier.
(defconst idlwave-identifier "[a-zA-Z_][a-zA-Z0-9$_]*" (#$ . 39404))
#@51 Regular expression matching IDL system variables.
(defconst idlwave-sysvar (concat "!" idlwave-identifier) (#$ . 39526))
#@49 Regular expression matching IDL variable names.
(defconst idlwave-variable (concat idlwave-identifier "\\|" idlwave-sysvar) (#$ . 39653))
#@41 Regular expression matching IDL labels.
(defconst idlwave-label (concat idlwave-identifier ":") (#$ . 39797))
(defconst idlwave-method-call (concat idlwave-identifier "\\s *->" "\\(\\s *" idlwave-identifier "::\\)?"))
#@799 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) (#$ . 40022))
#@30 IDL mode auto fill function.
(defvar idlwave-fill-function 'auto-fill-function (#$ . 41501))
#@35 IDL mode comment indent function.
(defvar idlwave-comment-indent-function 'comment-indent-function (#$ . 41600))
#@73 Character to be inserted for IDL comment indentation.
Normally a space.
(defvar idlwave-comment-indent-char -1 (#$ . 41719))
#@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 (#$ . 41851))
(defconst idlwave-mode-version "6.1_em22")
#@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 (#$ . 42089)]))
#@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!FF\207" [args lambda nil prin1-to-string if (idlwave-quoted) (progn (unexpand-abbrev) nil) append] 8 (#$ . 42337)]))
#@72 Run an inferior IDL, with I/O through buffer `(idlwave-shell-buffer)'.
(autoload 'idlwave-shell "idlw-shell" '(#$ . 42741) 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" '(#$ . 42925) t)
#@38 Save and run buffer under the shell.
(autoload 'idlwave-shell-save-and-run "idlw-shell" '(#$ . 43062) t)
#@33 Set breakpoint in current line.
(autoload 'idlwave-shell-break-here "idlw-shell" '(#$ . 43173) t)
#@29 Compile and run the region.
(autoload 'idlwave-shell-run-region "idlw-shell" '(#$ . 43277) t)
(byte-code "\300\301 M\207" [idlwave-debug-map make-sparse-keymap] 2)
#@26 Keymap used in IDL mode.
(defvar idlwave-mode-map (byte-code "\304 \305\306\307#\210\305\310\307#\210\305\311\312#\210\305\313\312#\210\305\314\315#\210\305\316\317#\210\305\320\321#\210\305\322\323#\210\305\324\325#\210\305\326\327#\210\305\330\331#\210\305\332\333#\210\305\334\335#\210\305\336\337#\210\305\340\341#\210\305\342\343#\210\305\344\345#\210\305\346\347#\210\305\350\351#\210\305\352\353#\210\305\354\355#\210\305\356\357#\210\305\360\361#\210\305\362\363#\210\305\364\365#\210\305\366\367#\210\305\370\371#\210\305\372\373#\210	<\203
	\374\232\204
\303	>\375\303\376	!\"\305\377\201@\n\203\322\201A\202\325\201BC\"!\201C#\210\305\377\201@\n\203\356\201D\202\361\201EC\"!\201F#\210\305\377\201@\n\203\n
\201G\202

\201HC\"!\201I#\210*\305\201J\201C#\210\305\201K\201F#\210\305\201L\201I#\210\305\201M\201N#\210\305\201O\201P#\210\305\201Q\201R#\210\305\201S\201T#\210\305\201U\201V#\210\305\201W\201X#\210\305\201Y\201Z#\210\305\201[\201\\#\210\305\201]\201^#\210\305\201_\201`#\210\305\201a\201b#\210\305\201c\201d#\210\305\201e\201f#\210\305\201g\201f#\210\305\201h\201f#\210\305\201i\201j#\210\305\201k\201l#\210\305\201m\201n#\210)\207" [map idlwave-shell-debug-modifiers mods-noshift shift 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 "" idlwave-debug-map 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 "" 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] 6) (#$ . 43447))
#@48 Syntax table in use in `idlwave-mode' buffers.
(defvar idlwave-mode-syntax-table (byte-code "\301 \302\303\304#\210\302\305\304#\210\302\306\304#\210\302\307\304#\210\302\310\304#\210\302\311\304#\210\302\312\304#\210\302\313\304#\210\302\314\304#\210\302\315\304#\210\302\316\317#\210\302\320\317#\210\302\321\304#\210\302\322\323#\210\302\324\325#\210\302\326\327#\210\302\330\323#\210\302\331\304#\210\302\332\333#\210\302\334\335#\210\302\336\335#\210)\207" [st make-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) (#$ . 46294))
#@64 Syntax table that treats symbol characters as word characters.
(defvar idlwave-find-symbol-syntax-table (byte-code "\302!\303\304\305	#\210\303\306\305	#\210\303\307\305	#\210\303\310\305	#\210	)\207" [idlwave-mode-syntax-table st copy-syntax-table modify-syntax-entry 36 "w" 95 33 46] 4) (#$ . 46941))
#@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 (#$ . 47252)]))
#@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\320\321\322\323
<\203[
\202]
C\257#\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] 9 (#$ . 47573)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\312\"\207" [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)] 3)
#@43 Abbreviation table used for IDLWAVE mode.
(defvar idlwave-mode-abbrev-table nil (#$ . 49703))
(define-abbrev-table 'idlwave-mode-abbrev-table nil)
#@169 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 (#$ . 49857)])
(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$\210\201\361\201\362N\204\204\201\363\201\361\201\362\201\364\201\365!#\210\201\366\201\367!\204\234\201\363\201\367\201\370\201\371#\210\300\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" "" #[nil "\300 \203\n\301 \210\302\207\303 \207" [idlwave-quoted unexpand-abbrev nil idlwave-case] 1 "(idlwave-case)"] "sw" #[nil "\300 \203\n\301 \210\302\207\303 \207" [idlwave-quoted unexpand-abbrev nil idlwave-switch] 1 "(idlwave-switch)"] "f" #[nil "\300 \203\n\301 \210\302\207\303 \207" [idlwave-quoted unexpand-abbrev nil idlwave-for] 1 "(idlwave-for)"] "fu" #[nil "\300 \203\n\301 \210\302\207\303 \207" [idlwave-quoted unexpand-abbrev nil idlwave-function] 1 "(idlwave-function)"] "pr" #[nil "\300 \203\n\301 \210\302\207\303 \207" [idlwave-quoted unexpand-abbrev nil idlwave-procedure] 1 "(idlwave-procedure)"] "r" #[nil "\300 \203\n\301 \210\302\207\303 \207" [idlwave-quoted unexpand-abbrev nil idlwave-repeat] 1 "(idlwave-repeat)"] "w" #[nil "\300 \203\n\301 \210\302\207\303 \207" [idlwave-quoted unexpand-abbrev nil idlwave-while] 1 "(idlwave-while)"] "i" #[nil "\300 \203\n\301 \210\302\207\303 \207" [idlwave-quoted unexpand-abbrev nil idlwave-if] 1 "(idlwave-if)"] "elif" #[nil "\300 \203\n\301 \210\302\207\303 \207" [idlwave-quoted unexpand-abbrev nil idlwave-elif] 1 "(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)) idlwave-mode-hook variable-documentation put purecopy "Hook run when entering IDLWAVE mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp idlwave-mode-map definition-name idlwave-mode] 5)
(defvar idlwave-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [idlwave-mode-map variable-documentation put purecopy "Keymap for `idlwave-mode'." boundp idlwave-mode-syntax-table definition-name idlwave-mode] 5)
(defvar idlwave-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [idlwave-mode-syntax-table variable-documentation put purecopy "Syntax table for `idlwave-mode'." idlwave-mode derived-mode-parent prog-mode] 5)
#@4863 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 URL `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\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324!\210\325\f!\210@AB\203T\326\327C\"\210\330B\306\331!\210\332\306D!\333L\210\306\334!\210\335\306\336!\210\337\306\340!\210\341 \306\342!\210\307\"\306\343!\210\330#\306\344!\210\307$\345\346!\203\241\347E\"\210\347F\"\210\307G\306H!\350L\210\351I\306\352!\210\330*\306\353!\210\354+\306\355!\210\356-\306\357!\210\330/\306\360!\210\3070\306\361!\210\3621\363\364!\203\343\365\364\366\"\210\306\367!\210J7\306\370!\210\3718\306\372!\210\373:\306\374!\210\375<\306\376!\210\377>\306\201K!\210\201NK\365\201O\311LM\337\201P\330\257\"\210\201Q\201R\201S\330\201T$\210\201Q\201U\201V\330\201T$\210\201Q\201W\201X\330\201T$\210\201Q\201W\201Y\330\201T$\210\201Z \210\201[ \210\201\\ \210)\201]\201^!\207" [delay-mode-hooks major-mode mode-name idlwave-mode-map idlwave-mode-syntax-table parent make-local-variable t prog-mode idlwave-mode "IDLWAVE" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table use-local-map set-syntax-table message "Emacs IDLWAVE mode version %s." nil indent-line-function idlwave-indent-and-action idlwave-comment-hook comment-start-skip ";+[ 	]*" comment-start ";" comment-add 1 abbrev-all-caps indent-tabs-mode completion-ignore-case featurep easymenu easy-menu-add 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 idlwave-mode-abbrev-table local-abbrev-table idlwave-startup-message idlwave-mode-version idlwave-comment-indent-function idlwave-mode-menu idlwave-mode-debug-menu abbrev-mode idlwave-fill-function comment-end idlwave-font-lock-defaults imenu-prev-index-position-function idlwave-begin-block-reg idlwave-end-block-reg idlwave-prev-index-position hs-special-modes-alist idlwave-forward-block add-hook post-command-hook idlwave-command-hook local kill-buffer-hook 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] 9 (#$ . 60253) nil])
(defvar idlwave-setup-done nil)
(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\203b\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 (#$ . 68268)])
#@43 Insert TAB in buffer in current position.
(defalias 'idlwave-hard-tab #[nil "\300c\207" ["	"] 1 (#$ . 68599) 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 (#$ . 68721))
#@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 (#$ . 68930)])
#@526 Reverse 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 (#$ . 69250)])
#@55 Return t if point is inside a comment, nil otherwise.
(defalias 'idlwave-in-comment #[nil "\212`\301 \205`V*\207" [here idlwave-goto-comment] 2 (#$ . 70287)])
#@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 \305 \306\307 \210\310\n\311#\211\203$\312 \203$\310\n\311#\211\204\313	!\210\2056\312 ?\2056\314u\210`+\207" [found data eos comment-start point-at-eol match-data nil beginning-of-line search-forward lim idlwave-in-quote store-match-data -1] 5 (#$ . 70457)])
#@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 (#$ . 70977)])
#@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 (#$ . 71155) 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 (#$ . 71460)])
#@120 Find 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	!\310 \311\211\311\211 \203\312 \210\313\n!\314\315\316\"\205\263!\205\263\212\nb\210\317\320\321\"\210`\317\322\321\"\210`\211V\203F
b\210\323\311x\210`
{\fb\210\324 A\211\205\262?\206\262\227\227\230\203t\325\322!\202\262\227\326\230\203\244\"\203\236\212b\210\327u\210\330\230\203\225\226\202\227c\210\331\332!\210)\325\322!\202\262\333 \210\334\335#\210\325\322!).\207" [pos last-abbrev-location last-abbrev-marker eol-pos begin-pos end-pos point-marker copy-marker point-at-eol 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 (#$ . 71765)])
(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 (#$ . 73285) nil])
#@59 Surround &, leaving room for && (which surround 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 (#$ . 73568)])
#@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 (#$ . 73894)])
#@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\205Si
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 (#$ . 74248)])
#@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 (#$ . 75214)])
#@60 Insert a newline and indent 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 (#$ . 75915) nil])
#@64 Compute indent for the beginning of the IDL comment delimiter.
(defalias 'idlwave-comment-hook #[nil "\305!\204\305	\206\f\306!\203i\207\305\n!\2034\212\307\310x\210n)\2032\311 \211<\203/@\2020)\207i\207\307\310x\210n\203@\312\202BiT\f]\207" [idlwave-no-change-comment idlwave-begin-line-comment idlwave-code-comment tem comment-column looking-at "^;" " 	" nil idlwave-calculate-indent 0] 3 (#$ . 76263)])
#@290 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 (#$ . 76691) nil])
#@98 Move 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 (#$ . 77557) nil])
#@91 Move 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 (#$ . 77815) 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 (#$ . 78091) 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 (#$ . 78306) 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 (#$ . 78595) 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 (#$ . 78919) "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 (#$ . 79173) 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 (#$ . 79353) 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 (#$ . 79527) 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 (#$ . 79736) nil])
#@103 Go down a block.
With ARG: ARG >= 0 go forwards, ARG < 0 go backwards.
Returns non-nil if successful.
(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 (#$ . 79939) "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 (#$ . 80603) 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 (#$ . 81233)])
#@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 "\301\302!\203\303\304\305#\205!\306\225b\207\212\307y\210\310 )\203\311 \207\312 \207" [idlwave-shell-prompt-pattern derived-mode-p idlwave-shell-mode re-search-backward nil t 0 -1 idlwave-is-continuation-line idlwave-previous-statement beginning-of-line] 4 (#$ . 81741) nil])
#@180 Move 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 (#$ . 82254) nil])
#@121 Move 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 (#$ . 82808) nil])
#@121 Move 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 (#$ . 83148) nil])
#@150 Move 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 (#$ . 83423) 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 \203b\210\202%`\307Zf\310=\203%b\210`)\207" [save-point lim re-search-forward ".*&" t 0 idlwave-quoted 2 38] 4 (#$ . 83876)])
#@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 (#$ . 84163)])
#@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\203sm\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$\203kS\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 (#$ . 84623)])
#@338 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 (#$ . 85633)])
#@926 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 (#$ . 86240)])
#@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 (#$ . 88004) "p"])
#@218 Indent 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 (#$ . 88589) nil])
#@447 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 (#$ . 89589)])
#@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 (#$ . 90288)])
#@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 (#$ . 90538)])
#@43 Indent 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 (#$ . 90854) 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 (#$ . 91213) 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 (#$ . 91465)])
#@145 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 (#$ . 92253)])
#@359 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\f
b\210\336\337!\204\241\336\340!\210\324\341!\203\307\335\225b\210\342 4\343\216\324\344!*?\205\353i\202\353\345\346\215\205\353\347 \206\346\324\344!\206\346\212\nb\210\350 \2115@@*\351=?\205\353i\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 (#$ . 92791)])
#@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\203o\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 (#$ . 95720)])
#@467 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\203d\202e\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\241b\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 (#$ . 96822) "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 (#$ . 97979)])
#@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 (#$ . 98439)])
#@135 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\202i)\207" [beginning-of-line " 	" nil 0] 2 (#$ . 98785)])
#@148 Test 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 (#$ . 99066)])
#@45 Test 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 (#$ . 99534)])
#@45 Test 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 (#$ . 99718)])
#@541 Search 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 (#$ . 99916)])
#@730 Fill 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\221
\312\310\211\211\211\211\211\211\211\211#$%&'\212\313 \210`)\212\314 \210`)\315\n	\"\210`%\306 \210`\316\317\320Q\321 \322#\210i&\323\324 `{!\211(\325P#
b\210\311#!\203x\311)!\204xo\204x\326y\210\202``
U\204\201\327y\210`
b\210\311#!\203\236\311)!\204\236m\204\236\327y\210\202\206\306 \210\311#!\203\257\311)!\203\262\326y\210\310\210m\203\277\330c\210\326u\210\331d`\327#*\204
+\203
\212\nb\210\332 )\211\203
'\306 \210`\nV\2033
\316,\321 \322#\210'iZ\211$\333V\203
%`Y\203	
%$\\%\334$\335\"c\210\326y\210\202\341`\nV\2033
\306 \210'\316,\321 \322#\210i^'\326y\210\202
(\334'&Z\335\"P(\316,\321 \322#\210i']%b\210\212\n\336\n\f\326#{$\337\n\336\n\f\326#\335\340\310%\210\341\nd	Z\342 \310$\210\n\336\n\f\326#|\210\nb\210$c\210)n\203\213
\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 "^[ 	]*" "+" point-at-eol t regexp-quote point-at-bol "[^;]" -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 (#$ . 100943) "P"])
#@316 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	\304 \305#\205i	G\\)\207\212\306 \210\307	\310 \305#\205%i)\207" [idlwave-use-last-hang-indent idlwave-hang-indent-regexp nil re-search-backward point-at-bol t beginning-of-line re-search-forward point-at-eol] 4 (#$ . 103105)])
#@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\334	\203\212\306 \210\307\n!)\205\334\310\311 \210\310\312\313 \205'\f\205'\314 !\315 \210+\212\316\210\311 \210)\212\306 \210\307\n!)\203w\"\205\333d`Z\212\317y\210\320 )#$#\205s\306 \210\321%\322 \323#\210\324 \210\325#!\210d$Zb*\202\333\212\316\210\326 )\203\240\212\306 \210\327\310w\210\330\212\317y\210\331 \332\310w\210`{)\261\210)\311 \202\333\212\316\210\313 \211\203\266\f\203\266\330f\333\261\210\334c\210)\203\331\f\203\322\212\306 \210\327\310w\210fc\210)\202\331\335 \210\336\337!\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 point-at-eol 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 (#$ . 103729)])
#@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) "	\204J?\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 (#$ . 105221) "P"])
#@214 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	\203eb\210\202-\305\210\306 \210\307 \210\310\311!\203-\312 \210\313y\314V\203-\315c\210`\203L@\203@\316@!\210\202LA@;\203LA@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 (#$ . 105671) "P"])
#@39 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 (#$ . 106370)])
#@343 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#\204eb\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 (#$ . 106744) 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 (#$ . 107662) "r"])
#@76 Return t if point is in a comment or quoted string.
Returns nil otherwise.
(defalias 'idlwave-quoted #[nil "\300 \206\301 \207" [idlwave-in-comment idlwave-in-quote] 1 (#$ . 107965)])
#@244 Return 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 \307 \210``\310 \311\211W\203o\312\313	\314#\203g\315\224Tb\210`S\316h!\317
!\203=`\320u\210\202\321
	\314#\317
!\203W\320u\210\321
	\314#\202D\203a`S\202b`\211\202``\211\202\322\f!\210\nV\205z\n.\207" [start eol bq endq data delim point-at-eol beginning-of-line match-data nil re-search-forward "[\"']" lim 0 char-to-string looking-at 1 search-forward store-match-data found] 5 (#$ . 108158)])
#@68 Determine if the character after point is a pointer dereference *.
(defalias 'idlwave-is-pointer-dereference #[(&optional limit) "\302f\303=\205\304 ?\205\212\302u\210\305\306\307Q	\310#)\207" [idlwave-idl-keywords limit nil 42 idlwave-in-quote re-search-backward "\\(" "\\|[[(*+-/=,^><]\\)\\s-*\\*" t] 4 (#$ . 108885)])
#@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\307!\203\310=\203	`\232\203\nc\207\311\312!\207\313=\203(\f\227
\227\2022\2032\f\226
\226\314 \315\316\317!\204C\320\321!\210\fc\210\212
c\210`)\204[\322\315#\210;\205f\323\324\"*\207" [this-command last-abbrev-location last-abbrev-text idlwave-abbrev-change-case s1 s2 derived-mode-p idlwave-shell-mode self-insert-command error "No templates in idlwave-shell" down point-at-bol nil looking-at "\\s-*\n" open-line 1 indent-region message "%s" end beg noindent prompt] 4 (#$ . 109218)])
#@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 (#$ . 110422)])
#@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 (#$ . 110616) 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 (#$ . 110850) 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 (#$ . 111058) nil])
#@36 Build skeleton IDL loop statement.
(defalias 'idlwave-for #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "for" " do begin\n\nendfor" "Loop expression"] 4 (#$ . 111274) nil])
#@34 Build skeleton IDL if statement.
(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 (#$ . 111481) 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 (#$ . 112339)])
(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])
#@132 List of buffers pulled up by IDLWAVE for special reasons.
Buffers in this list may be killed by `idlwave-kill-autoloaded-buffers'.
(defvar idlwave-outlawed-buffers nil (#$ . 113222))
(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])
#@452 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.

Buffers 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 (#$ . 113630) 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 (#$ . 114619)])
#@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 (#$ . 114833)])
#@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 (#$ . 115297)])
(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])
#@368 Create 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 (#$ . 116112) nil])
#@319 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 (#$ . 117843) "r\nP"])
(defvar idlwave-sint-routines '(nil))
(defvar idlwave-sint-keywords '(nil))
(defvar idlwave-sint-methods '(nil))
(defvar idlwave-sint-classes '(nil))
(defvar idlwave-sint-dirs '(nil))
(defvar idlwave-sint-libnames '(nil))
#@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--] 7 (#$ . 118785)])
(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 (#$ . 121358)])
#@201 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 (#$ . 121617)])
#@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 (#$ . 122606)])
#@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 (#$ . 123186)])
#@54 Holds the routine-info obtained by scanning buffers.
(defvar idlwave-system-routines nil (#$ . 123385))
#@54 Holds the routine-info obtained by scanning buffers.
(defvar idlwave-buffer-routines nil (#$ . 123495))
#@54 Holds the routine-info obtained by asking the shell.
(defvar idlwave-compiled-routines nil (#$ . 123605))
#@65 Holds the unresolved routine-info obtained by asking the shell.
(defvar idlwave-unresolved-routines nil (#$ . 123717))
#@54 Holds the procedure routine-info from the user scan.
(defvar idlwave-user-catalog-routines nil (#$ . 123842))
#@75 Holds the procedure routine-info from the .idlwave_catalog library files.
(defvar idlwave-library-catalog-routines nil (#$ . 123958))
#@61 Name of library catalog loaded from .idlwave_catalog files.
(defvar idlwave-library-catalog-libname nil (#$ . 124098))
#@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 (#$ . 124224))
#@53 Like `idlwave-path-alist', but with true filenames.
(defvar idlwave-true-path-alist nil (#$ . 124425))
#@60 Holds the combined procedure/function/method routine-info.
(defvar idlwave-routines nil (#$ . 124534))
#@41 Holds the class names known to IDLWAVE.
(defvar idlwave-class-alist nil (#$ . 124643))
#@54 The history of classes selected with the minibuffer.
(defvar idlwave-class-history nil (#$ . 124736))
(defvar idlwave-force-class-query nil)
#@75 The window configuration just before the completion buffer was displayed.
(defvar idlwave-before-completion-wconf nil (#$ . 124883))
#@48 The last cons cell in the system routine info.
(defvar idlwave-last-system-routine-info-cons-cell nil (#$ . 125022))
#@56 The background process currently updating the catalog.
(defvar idlwave-catalog-process nil (#$ . 125145))
#@141 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 (#$ . 125258)])
#@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 (#$ . 125848))
#@68 Rescan the previously selected directories.  For batch processing.
(defalias 'idlwave-rescan-catalog-directories #[nil "\300\301!\207" [idlwave-update-routine-info (16)] 2 (#$ . 126032)])
#@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 (#$ . 126227) 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 (#$ . 127571) "P\np"])
(defvar idlwave-load-rinfo-steps-done (make-vector 6 nil))
(defvar idlwave-load-rinfo-idle-timer nil)
(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])
(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])
(defvar idlwave-system-class-info nil)
#@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 (#$ . 131828))
#@49 Alist of system variables and their help files.
(defvar idlwave-executive-commands-alist nil (#$ . 132003))
(defvar idlwave-help-special-topic-words nil)
(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,-\203Q\312-\313P\n\"\203Q\n\314\225\310O
\2036

@\211)<\203/
)@*)A@+*\315=\203\310\302+\236A$\312\316$\"\203\210\317\320\311\310$$$\321+\236A\".\312\322\"\203\237\314\202\264\312\323\"\203\253\324\202\264\312\325\"\205\264\326/./$./HBI\210*\202/
*\327=\203/
\302+\236A%\303+\236A&\312\330%\"\203%
\331\324%\"\203\361\332\202\362\333'%\314\225\310O%'0\3100:\203!
0@\211%P&D(B(0A\2110\202
*\202/
%&D(B(
A\211\204U\"\326H\203F
\n\324\310OB\202\233
1\203R
(1\244(\334(\"(\314\2112\324X\203\230
\"2H\203\217
\335\n2\314=\203w
\336\202x
\337-\340\341\"2H\n-#\257(\",B,2T\2112\202]
),.\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 props result class #1=#:v #2=#:v #3=#:--cl-var-- extra-kws idx] 10])
(defalias 'idlwave-rinfo-group-keywords #[(kwds master-link) "\306\211\211\211\211\211\n\203S\n@\307
A@!\211A\f@
@\310\f\n\"\211\203B
B	\211\f\fAB\241\210*\202J\f
BD\nB\nA\211\n\204\310
\n\"\211\203q\n@=\203h\n\202x\311\n\"B\202x
C\nB\211.\207" [master-elt block linkfiles anchor link kwd nil idlwave-split-link-target assoc delq kwds #1=#:v #2=#:v master-link] 7])
(defalias 'idlwave-convert-xml-clean-statement-aliases #[(aliases) "\306\211\n\306:\203=@\307\f
\"\211\2036\310\311\3128\211\"\2036\312\233\211\313\314\315\211	$\240\210)\202A\211\202	,\306\207" [entry syntax aliases #1=#:--cl-var-- x idlwave-system-routines nil assoc string-match " +or +" 4 replace-match ", " t #2=#:c] 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\203pA@@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--] 6])
(defalias 'idlwave-convert-xml-clean-sysvar-aliases #[(aliases) "\306\211\n\306:\2038@\307\fA
\"\211\2031	>\204$	B\310	!\211\f@\240\210	
BA\211\202	*\n\306\n:\203V\n@\311\f
\"\210\nA\211\n\202@,\306\207" [remove-list alias aliases #1=#:--cl-var-- x idlwave-system-variables-alist nil assoc copy-sequence delq #2=#:--cl-var--] 4])
(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\203m@\211<\203d@A@\313=\203d\302\236A\314\304\236A!ABBA\211\2045\315\311\205y\316B\304\fDE\".\n\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] 7])
(defvar idlwave-xml-routine-info-file nil)
(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./\314\21101\314\21123\314\21145\315	!\204>\316\317	\"\210\202I\320	!\204I\316\321	\"\210\322\323!\210\324	!\322\325!\210\326\f\236\211\204a\316\327!\210\f\2116AA)\211G\211/\330\245\3147\322\331!\210\314\21189\314\211:;\314<\f\203{
\f@-\fA\nT-<\203\207-@.-A@\332\n
\"\313U\203\270\322\333\n\334_/\245\"\210.\335=\203\370\336\236\2111\203\330\337\236A1AB3B3\202\207\340-!\2112A<\203\35682\2448\202\2072;B;\202\207.\341=\203
\342-!\2110@:B:80A\2448\202\207.\343=\203I
\337\236A\344\236AB<B<\336\236\2111\203\2071A4\235\204\2071A4B4\202\207.\345=\203\207\336\236A\2111\203o
\337\236A\346\314O1\346\314OB5B5\202\207\347-!9B9\202\207\3503!\210\3514!\210\3525!\210	7\353 \210\322\354!.\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" 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 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 (#$ . 138433) 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])
(defvar idlwave-after-load-rinfo-hook nil)
(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 "\303	\304=\203\305\306!\210\307\310\311 !!\202.	\204\303\202.\312\313!\203.\305\314!\210\307pC!\315\316\"\211)\207" [res idlwave-scan-all-buffers-for-routine-info idlwave-buffer-routines nil t message "Scanning all buffers..." idlwave-get-routine-info-from-buffers reverse buffer-list derived-mode-p 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 (#$ . 144172)])
#@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 (#$ . 144759)])
(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])
#@79 Update `idlwave-routines' for current buffer.
Can run from `after-save-hook'.
(defalias 'idlwave-update-current-buffer-info #[(why) "\304\305!\205\306=\204	>\205\n\205\205\307\310\311\217\207" [idlwave-auto-routine-info-updates why idlwave-scan-all-buffers-for-routine-info idlwave-routines derived-mode-p 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 (#$ . 145361)])
#@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 (#$ . 146016)])
#@76 Call `idlwave-get-buffer-routine-info' on idlwave-mode buffers in BUFFERS.
(defalias 'idlwave-get-routine-info-from-buffers #[(buffers) "\305\211\211\212\211A@\211\203*\nq\210\306\307!\203\f\203\305\310\311\217\211	B\202)\312\313	\"+\207" [res routine-lists buf buffers buffer-file-name nil derived-mode-p idlwave-mode (idlwave-get-buffer-routine-info) ((error)) apply nconc] 4 (#$ . 146386)])
#@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 (#$ . 146801)])
#@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 (#$ . 147249)])
#@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 (#$ . 148595)])
#@389 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, it 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\202C)\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 (#$ . 148826) "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])
(defconst idlwave-user-catalog-widget-help-string "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")
#@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" #[(&rest ignore) "\304\305\"\211\306\211\203#@\307\nA>\204\310\n\311\"\210A\211\204
*\312	!)\207" [idlwave-widget path-list x --dolist-tail-- widget-get :path-dirs nil lib idlwave-path-alist-add-flag user idlwave-display-user-catalog-widget] 4] "Select All Non-Lib" #[(&rest ignore) "\304\305\"\211\306\211\203@\307\n\310\"\210A\211\204
*\311	!)\207" [idlwave-widget path-list x --dolist-tail-- widget-get :path-dirs nil idlwave-path-alist-remove-flag user idlwave-display-user-catalog-widget] 4] "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 (#$ . 151316) 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 \210r\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) "\205R	\203\306	!\202\307\310\n\"\311\312\211\211\211\203*\313!\210\211A@\211\203=\314\315\215\210\202*\204E\205P\313\316P!.\207" [idlwave-use-library-catalogs idlwave-library-path idlwave-path-alist all-routines catalog dir 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-entry old-libname dirs message-base no-load idlwave-library-catalog-routines] 6 (#$ . 157208)])
#@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" (#$ . 158722))
#@61 Remember if the routine info procedure is already compiled.
(defvar idlwave-idlwave_routine_info-compiled nil (#$ . 162489))
(defalias 'idlwave-shell-compile-helper-routines #[(&optional wait) "\203\f\305\306\307!!\2046r\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 (#$ . 163446)])
(defvar idlwave-completion-help-info nil)
(defvar idlwave-completion-help-links nil)
(defvar idlwave-current-obj_new-class nil)
(defvar idlwave-complete-special nil)
#@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\2039\203\310	\n#\202!\311 \3128\313\232\314\232\2054\315\316!C@	\203M\317\320	\"\203M	\321\211\224O	\321\225\322O\204hA\242\323=\203h\324\325!\203hAB\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\202

F\"\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\202v
F\"\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\201QK\341\nNG;&\211N\204\332\201R\377\nK\"\"\210\201SKIFMG\257D\350\201S\211N\322\353\201T\377\nK\"\201UN\235\204P\201VN\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\201QK\363\nNG;&N\n\204\371K\226\201\\\230\203\371P\201]P\202\376\377\nK\"ON\204
\332\201^O\"\210\201SKIF\322G\257D\350\201S\211N\322\353\201_O\201`N\235\204=\201aN\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 (#$ . 164095) "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 (#$ . 169453))
(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\203E9\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 (#$ . 172302)])
(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 (#$ . 172826)])
(defalias 'idlwave-rinfo-assq #[(name type class list) "\300\301\215\207" [exit (byte-code "\305	\n\236\211\205-\306=\204A@=\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 (#$ . 173565)])
#@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 (#$ . 174286)])
#@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\202A\211\204\310\207" [entries cnt file idlwave-routine-source-file 3 idlwave-syslib-p throw exit nil] 4)] 2 (#$ . 174620)])
#@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 (#$ . 175008)])
#@148 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 (#$ . 175203)])
#@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 (#$ . 175690)])
#@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 (#$ . 176240)])
#@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 (#$ . 176447)])
#@132 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 (#$ . 176657)])
#@96 List of special functions for determining class.
Must accept two arguments: `apos' and `info'.
(defvar idlwave-determine-class-special nil (#$ . 176961))
(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=\203^
&\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&!	\203Z
	\313=\204Z
+\203P
&\203P
\320\343\344\217\210AA\2111	\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 #1=#:c] 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 (#$ . 178997)])
(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\nb)\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\202g\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\202h\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 (#$ . 183562)])
#@49 A form to evaluate after successful completion.
(defvar idlwave-complete-after-success-form nil (#$ . 184305))
#@72 A form to evaluate after completion selection in *Completions* buffer.
(defvar idlwave-complete-after-success-form-force nil (#$ . 184422))
#@60 A mark pointing to the beginning of the completion string.
(defconst idlwave-completion-mark (make-marker) (#$ . 184568))
#@383 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\"\202U
!\"\232\204\304 \306=\204\304	\n|\210\f!\230\203\250\f\322\230\203\236+\203\250,\204\250\"\202\252 c\210\320 #)#\306=\203\300\314%	#\210\306\202U
 \306=\204\352\323\324\f#-\206\327)#!\211G\325U\203\374!\"\232\203\374\314%	#\210\326\327\f.#\210\307\202U
\326\330!\210*\204
\331\332#\"\210#
>/\3060\333#\334\"#1\203+
1#!#\f!\230\203I
\f\322\230\203=
+\203I
,\204I
\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 (#$ . 184697)])
#@28 Complete a class at point.
(defalias 'idlwave-complete-class #[nil "\301 \210\302\212\303\304`\305Z\302#\205eb\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" #[(list) "\301\302\"\207" [list mapcar #[(x) "\304!\302	\236A@\211\203\nBB*\207" [x entry link idlwave-completion-help-links idlwave-class-info] 3]] 3]] 8 (#$ . 186857) 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])
#@139 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\f\2038\fG\307U\203\f@\2028
\203 \305\f\310\"\311\312C\313\314\f\"\"CB\315	\"\316	\"\n+\207" [idlwave-max-popup-menu-items menu rtn maxpopup list sort nil 1 #[(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 (#$ . 189108)])
#@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 (#$ . 189649)])
#@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 (#$ . 189984)])
(defvar idlwave-completion-setup-hook nil)
#@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 (#$ . 190385)])
#@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 (#$ . 190926)])
#@60 Call FUNCTION as a completion chooser and pass ARGS to it.
(defalias 'idlwave-choose #[(function &rest args) "\306\307	\n\"\210)\310\311!\203'\312\303!\203'\204'\212\313\314x\210`)\315\f`\316#\210)\317
!\207" [completion-ignore-case function args font-lock-mode beg idlwave-complete-after-success-form-force t apply derived-mode-p idlwave-shell-mode boundp "a-zA-Z0-9_" nil remove-text-properties (face nil) eval] 4 (#$ . 191680)])
(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 (#$ . 192316)])
#@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#!\203\245\324 $\325\216%&r\326\327!q\210p\330 \210&%\311\211'(\331\211)\331*+\332 \210\333\334!\210+\211,-\311.\211/\203\227/@.\335.A@!\210\335\336!\210/A\211/\204~*\337,!\210+\340 *\202\250\340 \316\311!\210\341\342\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 current-window-configuration ((set-window-configuration #1=#:wconfig)) get-buffer-create "*Completions*" kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook princ "\n" internal-temp-output-buffer-show read-char 2 assoc delay #1# default-directory #2=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #3=#:buf standard-output x --dolist-tail--] 8 (#$ . 192589)])
#@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 (#$ . 194333)])
#@55 Set the buffer-local value of VAR in BUFFER to VALUE.
(defalias 'idlwave-set-local #[(var value &optional buffer) "r\206pq\210\303	!\nL)\207" [buffer var value make-local-variable] 2 (#$ . 195235)])
#@72 Return the value of VAR in BUFFER, but only if VAR is local to BUFFER.
(defalias 'idlwave-local-value #[(var &optional buffer) "r\206pq\210\302	p\"\205	J)\207" [buffer var local-variable-p] 3 (#$ . 195443)])
#@60 Keymap for `completion-list-mode' with `idlwave-complete'.
(defvar idlwave-completion-map nil (#$ . 195662))
(defalias 'idlwave-display-completion-list-xemacs #[(list &rest cl-args) "r\306\307!q\210p\310 \210	\311\211\312\211\312\313 \210\314\315!\210+\211\316\317\320\321%\210\322!\210+r\307q\210\323\206G\324\325 !\211!)\207" [default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks get-buffer-create "*Completions*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook apply display-completion-list :activate-callback idlwave-default-choose-completion internal-temp-output-buffer-show use-local-map idlwave-make-modified-completion-map-xemacs current-local-map inhibit-read-only #2=#:buf standard-output list cl-args idlwave-completion-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 (#$ . 196517)])
#@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 (#$ . 196743)])
#@58 Display completion list and install the choose wrappers.
(defalias 'idlwave-display-completion-list-emacs #[(list) "r\306\307!q\210p\310 \210	\311\211\312\211\312\313 \210\314\315!\210+\211\316!\210\317!\210+r\307q\210\320\206B\321\322 !\211!)\207" [default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks get-buffer-create "*Completions*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook display-completion-list internal-temp-output-buffer-show use-local-map idlwave-make-modified-completion-map-emacs current-local-map inhibit-read-only #2=#:buf standard-output list idlwave-completion-map] 4 (#$ . 197107)])
#@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 (#$ . 197827)])
#@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 (#$ . 198264) 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 (#$ . 198462) "e"])
#@74 Regexp for skipping continued blank or comment-only lines in structures.
(defvar idlwave-struct-skip "[ 	]*\\(\\$.*\n\\(^[ 	]*\\(\\$[ 	]*\\)?\\(;.*\\)?\n\\)*\\)?[ 	]*" (#$ . 198689))
#@28 Regexp for structure tags.
(defvar idlwave-struct-tag-regexp (concat "[{,]" idlwave-struct-skip "\\([a-zA-Z][a-zA-Z0-9_]*\\)" "[ 	]*:") (#$ . 198878))
#@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 (#$ . 199036)])
#@53 Find a given TAG in the structure defined at point.
(defalias 'idlwave-find-struct-tag #[(tag) "\304 \211A\305\306\307\310Q	\305#+\207" [borders end case-fold-search tag idlwave-struct-borders t re-search-forward "\\(^[ 	]*\\|[,{][ 	]*\\)" "[ 	]*:"] 5 (#$ . 199557)])
#@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 (#$ . 199836)])
#@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 (#$ . 200447)])
#@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 (#$ . 200778)])
#@413 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 (#$ . 201016)])
(defvar idlwave-class-info nil)
(defvar idlwave-class-reset nil)
(byte-code "\300\301\302\"\210\300\303\304\"\207" [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) "\301\236\302@\303\"\240\210	\205	\304\305	A\"\241)\207" [entry inherits idlwave-sintern-class set mapcar #[(x) "\301\302\"\207" [x idlwave-sintern-class set] 3]] 4 (#$ . 202793)])
#@273 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\310\311\227\312\313R\307\306#\2057\f\203/\212\314 \210`)\315\307\306	#\211\2057\f!\210\202\315\307
\2066\"+\207" [name end-lim case-fold-search class all-hook alt-class t nil re-search-forward "^[ 	]*pro[ 	]+" "__define" "\\>" idlwave-end-of-subprogram idlwave-find-structure-definition] 5 (#$ . 203083)])
#@40 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 (#$ . 203775)])
#@67 Scan all class and named structure info in the class__define pro.
(defalias 'idlwave-scan-class-info #[(class) "\305\306	!\211@\nA\307	!?\206\f?\205\310!??\205K\212\f\203-\fq\210\202B\311\312!q\210\313 \210\314\315!\204>\315 \210\316!\210\212\317b\210\320	\321\"*-\207" [idlwave-auto-routine-info-updates class filebuf file buf nil idlwave-class-file-or-buffer idlwave-sintern-class file-regular-p get-buffer-create " *IDLWAVE-tmp*" erase-buffer derived-mode-p 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 (#$ . 204086)])
#@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 (#$ . 204916)])
#@34 Return the native tags in CLASS.
(defalias 'idlwave-class-tags #[(class) "\301\302!\236A\207" [class tags idlwave-class-info] 3 (#$ . 205085)])
#@42 Return the direct superclasses of CLASS.
(defalias 'idlwave-class-inherits #[(class) "\301\302!\236A\207" [class inherits idlwave-class-info] 3 (#$ . 205236)])
#@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 (#$ . 205403)])
#@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 (#$ . 205795)])
#@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 (#$ . 206518)])
#@69 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 (#$ . 207123)])
(defvar idlwave-current-tags-class nil)
(defvar idlwave-current-class-tags nil)
(defvar idlwave-current-native-class-tags nil)
(defvar idlwave-sint-class-tags nil)
(byte-code "\300\301!\210\302\303\304\"\210\305\306\307\"\207" [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 (#$ . 207937) 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 (#$ . 208941)])
(defvar idlwave-sint-sysvars nil)
(defvar idlwave-sint-sysvartags nil)
(byte-code "\300\301!\210\300\302!\210\303\304\305\"\210\306\307\310\"\210\306\311\312\"\207" [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 (#$ . 209788) nil])
(defalias 'idlwave-complete-sysvar-help #[(mode word) "A@\206	\306	\n\"\f\307=\203$	;\205;\205;\310\236A@\202;\f\311=\2038\205;\310\236A@\211\202;\312\313!*\207" [idlwave-completion-help-info word idlwave-system-variables-alist entry mode idlw-help-link assoc test link set error "This should not happen"] 4])
(defalias 'idlwave-complete-sysvar-tag-help #[(mode word) "A@\306	\n\"\304\236A\307\236A@\310\311=\203,;\205V\205V
\202V\312=\203S\205V\313\f\314#A\211\203L\315
\"\202M
\211\202V\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 mode word idlw-help-link] 4])
#@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 (#$ . 211481)])
#@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 (#$ . 211717)])
(defvar idlwave-help-do-class-struct-tag nil)
(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" idlw-help-name idlw-help-link 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 (#$ . 212629)])
(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 (#$ . 213845)])
#@59 Goto the *Completions* buffer and fontify the class info.
(defalias 'idlwave-completion-fontify-classes #[nil "\301\302!\205%r\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 (#$ . 214511)])
(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 (#$ . 215117)])
#@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 (#$ . 215987) "eP"])
(defvar idlwave-last-context-help-pos nil)
#@442 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 routines 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 (#$ . 216241) "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 (#$ . 216803) "eP"])
#@454 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 (#$ . 217012) "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 (#$ . 218291) "P"])
(defalias 'idlwave-find-module-this-file #[nil "\300\301!\207" [idlwave-find-module (4)] 2 nil nil])
#@278 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 (#$ . 219716) "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 (#$ . 222445)])
#@71 Call `idlwave-what-module' and find the inherited class if necessary.
(defalias 'idlwave-what-module-find-class #[nil "\302 \3038G\304U\203 	;\203 @A@\305\306\"E\202!*\207" [module class idlwave-what-module 2 3 apply idlwave-find-inherited-class] 5 (#$ . 223680)])
#@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 (#$ . 223962)])
#@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 (#$ . 224237)])
#@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\203J\310\311\312\"\203J\212\313 \210`)\211`{\306\314\315\316\"\203I\317\320\321\"!\211\203I\f\211\203I\322%\323\324\325\326!\327\f\330 $\331\"\"%,\f\306=\203_\332\333\334	\330 \"\"\210\335%!%&\203\341'\203\341\f;\203\341(\204\205\336\337!%\236\204\205\336\340!%\236\203\341'\314)*\341\342\215*\203\341\330 +\314,+:\203\332+@,\343,8\203\321\343,8&>\203\321,A@-=\203\321,@	=\203\321\332\344\323,\331\"\"\210+A\211+\202\234*\335%!%%)\207" [case-fold-search name bos string class idlwave-current-obj_new-class t "OBJ_NEW" derived-mode-p 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\205A@	=\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] keywords super-classes idlwave-keyword-class-inheritance system re regexps #1=#:--cl-var-- entry type] 9 (#$ . 224789)])
#@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 (#$ . 226476)])
(defvar idlwave-rinfo-mouse-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210)\207" [map 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] 4))
(defvar idlwave-rinfo-map (byte-code "\301 \302\303\304#\210)\207" [map make-sparse-keymap define-key "q" idlwave-quit-help] 4))
(defvar idlwave-popup-source nil)
(defvar idlwave-rinfo-marker (make-marker))
(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\204R`\330\223\210r\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\273
PXV\203\273
\367\201_X\"c\210\330\211C\202\275
eb\210\201`T)\201a\343!\210\201b\343!\211O\205\204Y\205\204\201c Z\201d\216\201eO!\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\"\206A0\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\3340A\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 (#$ . 231817)])
#@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 (#$ . 233323)])
(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])
#@137 Do 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 (#$ . 234042) "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 (#$ . 235554)])
#@71 List the load path shadows of all routines defined in current buffer.
(defalias 'idlwave-list-buffer-load-path-shadows #[(&optional arg) "\300 \210\301\302!\203\303\304\305\306!\307#\207\310\311!\207" [idlwave-routines derived-mode-p 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 (#$ . 236141) "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 (#$ . 236568) "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 (#$ . 237244) "P"])
#@69 Internal variable used to influence `idlwave-routine-twin-compare'.
(defvar idlwave-sort-prefer-buffer-info t (#$ . 237469))
#@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!\210r\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\224CTC\355\356\357\352E8E@\"EA@\360=\203-
\361\202.
\362#c\210G\211AG@\211H\203\224\313\363E@EA@\352E8ED>\"J\364\365HJ#\210\2021
eb\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 (#$ . 237601)])
(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 (#$ . 240655)])
#@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\241
T\311	8\211@\211\3118B\312!\313=\203Q\202^\203]\314!\202^\315\203t\204t\316!\203t\317\320\"\211\203\221	AA\211@B\240\210)\202$CEB\202$\237\203\265\321\313\236\"\322 \203\310\320\313\"\211\203\310	\323\240\210\324\325\".\f\207" [entries entry idlwave-twin-name type idlwave-twin-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 #1=#:c] 4 (#$ . 241260)])
(defalias 'idlwave-xor '(macro . #[(a b) "\302\303	E\304\302	EDE\207" [a b and or not] 6]))
#@281 Compare two routine info entries for sorting.
This is the general case.  It first compares 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 (#$ . 242448)])
#@147 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 idlwave-twin-name type idlwave-twin-class asrc atype 2 3 idlwave-routine-source-file idlwave-routine-twin-compare file-truename b bsrc btype afile bfile] 6 (#$ . 243143)])
#@221 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 IDLWAVE-TWIN-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\3711\205\371\326\327+\"\330\2302\204
\203
\203
\204
\202\313
!\204
\"\203-
!\203(
\"\204-
\"\202\313
3\203K
#\204<
$\203K
#\203F
$\204K
#\202\313
\204U
 \203d
\203_
 \204d
\202\313
&\204n
'\203}
&\203x
'\204}
&\202\313
/\204\207
1\203\226
/\203\221
1\204\226
/\202\313
,\203\276
/\203\276
1\203\276
0\204\257
2\203\276
0\203\271
2\204\276
2\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 idlwave-twin-class idlwave-twin-name fname-re anamep adefp bnamep bdefp idlwave-sort-prefer-buffer-info] 5 (#$ . 243673)])
(defalias 'idlwave-routine-source-file #[(source) "\3018\203\302A@\3018\"\207A@\207" [source 2 expand-file-name] 4])
#@44 Downcase if string, else return unchanged.
(defalias 'idlwave-downcase-safe #[(string) ";\203\227\207\207" [string] 1 (#$ . 245467)])
#@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 (#$ . 245612)])
#@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 (#$ . 245782)])
#@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 (#$ . 245964)])
#@36 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 (#$ . 246262)])
#@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 (#$ . 246467)])
#@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 (#$ . 246666)])
#@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 (#$ . 246853)])
#@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 (#$ . 247278)])
#@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 (#$ . 247569)])
#@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 (#$ . 247954)])
(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 (#$ . 249191) 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 (#$ . 249441) nil])
(defvar idlwave-mode-menu-def '("IDLWAVE" ["PRO/FUNC menu" idlwave-function-menu t] ("Motion" ["Subprogram Start" idlwave-beginning-of-subprogram t] ["Subprogram End" idlwave-end-of-subprogram t] ["Block Start" idlwave-beginning-of-block t] ["Block End" idlwave-end-of-block t] ["Up Block" idlwave-backward-up-block t] ["Down Block" idlwave-down-block t] ["Skip Block Backward" idlwave-backward-block t] ["Skip Block Forward" idlwave-forward-block t]) ("Mark" ["Subprogram" idlwave-mark-subprogram t] ["Block" idlwave-mark-block t] ["Header" idlwave-mark-doclib t]) ("Format" ["Indent 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])))
(defvar idlwave-mode-debug-menu-def '("Debug" ["Start IDL shell" idlwave-shell t] ["Save and .RUN buffer" idlwave-shell-save-and-run (and (boundp 'idlwave-shell-automatic-start) idlwave-shell-automatic-start)]))
(byte-code "\303\304!\204
\305\306\307\"\203#\310\311!\210\312\313\314	$\210\315\311!\210\312\316\314\n$\210\311\207" [idlwave-mode-map idlwave-mode-menu-def idlwave-mode-debug-menu-def featurep easymenu load "easymenu" t (lambda (#1=#:def-tmp-var) (defvar idlwave-mode-menu #1# #2="IDL and WAVE CL editing menu")) nil easy-menu-do-define idlwave-mode-menu #2# (lambda (#1#) (defvar idlwave-mode-debug-menu #1# "IDL and WAVE CL editing menu")) idlwave-mode-debug-menu] 5)
#@57 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 (#$ . 253962) 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 (#$ . 254197) 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 (#$ . 254942) 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 (#$ . 255125) nil])
#@52 Read documentation for IDLWAVE in the info system.
(defalias 'idlwave-info #[nil "\300\301!\207" [info "idlwave"] 2 (#$ . 255320) 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	#()r\317\320!q\210p\321 \210)(\307\211*+\322\211,\322-.\323 \210\324\325!\210+\211/01\203v\326\327!\210\326\330!\210\326\315\n\331\332\333$!\210\326\315\n\334\335\336$!\210\202\220\326\337!\210\326\340!\210\326\315\n\331\341\342$!\210\326\315\n\334\343\342$!\210&\3072\2113\203\2773@\2112@2A@\34428\326\315\n
\f$!\2103A\2113\204\233*\345/!\210.r\320q\210\322\2114)\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" get-buffer-create "*Help*" kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook 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# "------" 2 internal-temp-output-buffer-show abbrevs table default-directory #2=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #3=#:buf standard-output arg list --dolist-tail-- truncate-lines] 9 (#$ . 255463) "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)