| Server IP : 217.160.0.212 / Your IP : 216.73.216.141 Web Server : Apache System : Linux www 6.18.51-i1-ampere #1196 SMP Fri Sep 11 20:43:55 CEST 2026 aarch64 User : sws1073854427 ( 1073854427) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /usr/share/emacs/28.2/lisp/progmodes/ |
Upload File : |
;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.
(byte-code "\300\301!\210\302\303\304\305\306\307\310\311\310\312\310\313\310\314\315\316\317\320&\210\302\321\304\322\317\303%\210\323\324\325\326\327DD\330\317\321\331\332&\210\323\333\325\326\334DD\335\317\321\331\332&\210\323\336\325\326\337DD\340\317\321\331\332&\210\323\341\325\326\342DD\343\317\321\331\332&\210\323\344\325\326\345DD\346\317\321\331\332&\210\323\347\325\326\350DD\351\317\321\331\352&\210\323\353\325\326\354DD\355\317\321\331\352&\210\323\356\325\326\357DD\360\317\321\331\352&\210\323\361\325\326\362DD\363\317\321\331\364&\210\323\365\325\326\366DD\367\317\321\331\352&\210\323\370\325\326\371DD\372\317\321\331\352&\210\323\373\325\326\374DD\375\317\321\331\352&\210\323\376\325\326\377DD\201@ \317\321\331\352&\210\323\201A \325\326\201B DD\201C \317\321\331\364&\210\323\201D \325\326\201E DD\201F \317\321\331\201G &\210\323\201H \325\326\201I DD\201J \317\321\331\364&\210\302\201K \304\201L \317\303%\210\323\201M \325\326\201N DD\201O \317\201K \331\352&\210\323\201P \325\326\201Q DD\201R \317\201K \331\201S &\210\323\201T \325\326\201U DD\201V \317\201K \331\201W &\210\323\201X \325\326\201Y DD\201Z \317\201K \331\352&\210\323\201[ \325\326\201\\ DD\201] \317\201K \331\201^ &\210\323\201_ \325\326\201` DD\201a \317\201K \331\332&\210\323\201b \325\326\201c DD\201d \317\201K \331\201e &\210\323\201f \325\326\201g DD\201h \317\201K \331\201i &\210\323\201j \325\326\201k DD\201l \201m \201n \317\201K \331\201o & \207" [require idlw-help custom-declare-group idlwave nil "Major mode for editing IDL .pro files." :tag "IDLWAVE" :link (url-link :tag "Website" "https://github.com/jdtsmith/idlwave") (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 funcall function #[0 "\300\207" [2] 1 #1=""] "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 #[0 "\300\207" [3] 1 #1#] "Extra indentation applied to block lines.\nIf you change this, you probably also want to change `idlwave-end-offset'." idlwave-end-offset #[0 "\300\207" [-3] 1 #1#] "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 #[0 "\300\207" [3] 1 #1#] "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 #[0 "\300\207" [40] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [nil] 1 #1#] "Non-nil means indent continuation lines with parens by nesting\nlines at consecutively deeper levels." idlwave-hanging-indent #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" ["- "] 1 #1#] "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 #[0 "\300\207" [nil] 1 #1#] "If non-nil then use last match on line for `idlwave-indent-regexp'." idlwave-fill-comment-line-only #[0 "\300\207" [t] 1 #1#] "If non-nil then auto fill will only operate on comment lines." idlwave-auto-fill-split-string #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [";;;"] 1 #1#] "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." idlwave-begin-line-comment #[0 "\300\207" [nil] 1 #1#] "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 #[0 "\300\207" [";;[^;]"] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [10] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "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.\n`current' 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 #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [(find-file save-buffer kill-buffer compile-buffer)] 1 #1#] "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 #[0 "\300\207" [5] 1 #1#] "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 #[0 "\300\207" [nil] 1 #1#] "Library path for Windows and Mac OS (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 MS-Windows, the\nIDLWAVE shell does not work. In this case, this variable can be\nset to specify the paths where IDLWAVE can find PRO files. The\nshell will only be asked for a list of paths when this variable\nis 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\nalso `idlwave-system-directory'." (repeat (directory)) idlwave-system-directory #[0 "\300\207" [#1#] 1 #1#] "The IDL system directory for Windows and Mac OS. 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 #[0 "\300\301\302\"\207" [locate-user-emacs-file "idlwave" ".idlwave"] 3 #1#] "Directory for configuration files and user-library catalog." :version "24.4" 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\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\307\310\315&\210\316\317\320\321\322\323\306\324&\207" [custom-declare-variable idlwave-special-lib-alist funcall function #[0 "\300\207" [nil] 1 #1=""] "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 #[0 "\300\207" [t] 1 #1#] "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 nil "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\305DD\306\307\310\311\312\313\314ED&\210\301\315\303\304\316DD\317\307\310\311\320&\210\301\321\303\304\322DD\323\307\310\311\320&\210\301\324\303\304\325DD\326\307\310\311\320&\210\301\327\303\304\330DD\331\307\310\311\320&\210\301\332\303\304\333DD\334\307\335\311\320&\210\301\336\303\304\337DD\340\307\335\311\341&\210\301\342\303\304\343DD\344\307\310\311\345&\210\301\346\303\304\347DD\350\307\310\311\320&\210\301\351\303\304\352DD\353\307\310\311\354&\210\301\355\303\304\356DD\357\307\310\311\320&\210\301\360\303\304\361DD\362\307\310\311\363&\210\301\364\303\304\365DD\366\307\310\311\320&\210\301\367\303\304\370DD\371\307\310\311\320&\210\301\372\303\304\373DD\374\307\310\311\375&\210\301\376\303\304\377DD\201@ \307\310\311\320&\210\201A \201B \201C \201D \307\201E %\210\301\201F \303\304\201G DD\201H \307\201B \311\320&\210\301\201I \303\304\201J DD\201K \307\201B \311\201L &\210\301\201M \303\304\201N DD\201O \307\201B \311\320&\210\301\201P \303\304\201Q DD\201R \307\201B \311\201S &\210\301\201T \303\304\201U DD\201V \307\201B \311\320&\210\301\201W \303\304\201X DD\201Y \307\201B \311\320&\210\301\201Z \303\304\201[ DD\201\\ \307\201B \311\320&\210\301\201] \303\304\201^ DD\201_ \307\201B \311\320&\210\301\201` \303\304\201a DD\201b \307\201B \311\320&\210\301\201c \303\304\201d DD\201e \307\201B \311\320&\207" [idlwave-tmp custom-declare-variable idlwave-completion-case funcall function #[0 "\300\207" [((routine . upcase) (keyword . upcase) (class . preserve) (method . preserve))] 1 #1=""] "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 #[0 "\300\207" [nil] 1 #1#] "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 #[0 "\300\207" [nil] 1 #1#] "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 #[0 "\300\207" [nil] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [("^[gs]etproperty$" "^init$")] 1 #1#] "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 #[0 "\300\207" [1] 1 #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." (choice (const :tag "Don't show" nil) (integer :tag "Number of classes shown" 1)) idlwave-completion-fontify-classes #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [((method-default) (keyword-default))] 1 #1#] "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 #1#) (boolean :tag "Determine class for this method")))) idlwave-store-inquired-class #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [bold] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "Non-nil means, resize the Routine-info *Help* window to fit the content." idlwave-keyword-completion-adds-equal #[0 "\300\207" [t] 1 #1#] "Non-nil means, completion automatically adds `=' after completed keywords." idlwave-function-completion-adds-paren #[0 "\300\207" [t] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "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 nil "IDLWAVE performs actions when expanding abbreviations or indenting lines.\nThe variables in this group govern this." idlwave idlwave-do-actions #[0 "\300\207" [nil] 1 #1#] "Non-nil means performs actions when indenting.\nThe actions that can be performed are listed in `idlwave-indent-action-table'." idlwave-abbrev-start-char #[0 "\300\207" ["\\"] 1 #1#] "A single character string used to start abbreviations in abbrev mode.\nPossible characters to choose 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 #[0 "\300\207" [nil] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "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) (other :tag "Keep space near `='" keep)) idlwave-show-block #[0 "\300\207" [t] 1 #1#] "Non-nil means point blinks to block beginning for `idlwave-show-begin'." idlwave-expand-generic-end #[0 "\300\207" [nil] 1 #1#] "Non-nil means expand generic END to ENDIF/ENDELSE/ENDWHILE etc." idlwave-reindent-end #[0 "\300\207" [t] 1 #1#] "Non-nil means re-indent line after END was typed." idlwave-abbrev-move #[0 "\300\207" [t] 1 #1#] "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-modify-abbrev'." idlwave-abbrev-change-case #[0 "\300\207" [nil] 1 #1#] "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 #[0 "\300\207" [nil] 1 #1#] "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 (#$ . 27940))
#@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 (#$ . 28380))
(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") (#$ . 28942))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\307\310\303&\210\300\315\302\303\316DD\317\306\307\310\320&\210\300\321\302\303\322DD\323\306\307\310\324&\210\300\325\302\303\326DD\327\306\307\310\324&\210\330\331\332\333\306\334%\210\300\335\302\303\336DD\337\306\331\310\320&\210\300\340\302\303\341DD\342\310\343\306\331&\210\300\344\302\303\345DD\346\306\331\310\320&\210\300\347\302\303\350DD\351\306\352\310\353&\210\300\354\302\303\355DD\356\306\352\310\311&\210\330\357\332\360\361\362\306\334&\210\300\363\302\303\364DD\365\306\357\310\311&\210\300\366\302\303\367DD\370\306\357\310\371&\210\300\372\302\303\373DD\374\306\357\310\375&\210\300\376\302\303\377DD\201@ \306\357\310\375&\210\201A \376\201B \201C #\207" [custom-declare-variable idlwave-header-to-beginning-of-file funcall function #[0 "\300\207" [t] 1 #1=""] "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 #[0 "\300\207" [idlwave-default-insert-timestamp] 1 #1#] "The hook function used to update the timestamp of a function." idlwave-doc-modifications-keyword #[0 "\300\207" ["HISTORY"] 1 #1#] "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 #[0 "\300\207" ["^;+\\+"] 1 #1#] "Regexp matching the start of a document library header." regexp idlwave-doclib-end #[0 "\300\207" ["^;+-"] 1 #1#] "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 #[0 "\300\207" ["idl"] 1 #1#] "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 #[0 "\300\207" [nil] 1 #1#] "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 #1#))) idlwave-help-application #[0 "\300\207" ["idlhelp"] 1 #1#] "The external application providing reference help for programming.\nObsolete, if the IDL Assistant is being used for help." idlwave-shell-debug-modifiers #[0 "\300\207" [nil] 1 #1#] "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 #[0 "\300\207" [nil] 1 #1#] "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 #[0 "\300\207" [t] 1 #1#] "Non-nil displays a startup message when `idlwave-mode' is first called." idlwave-default-font-lock-items #[0 "\300\207" [(pros-and-functions batch-files idlwave-idl-keywords label goto common-blocks class-arrows)] 1 #1#] "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\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 "Object Arrows with class property " class-arrows)) idlwave-mode-hook #[0 "\300\207" [nil] 1 #1#] "Normal hook. Executed when a buffer is put into `idlwave-mode'." hook idlwave-load-hook #[0 "\300\207" [nil] 1 #1#] "Normal hook. Executed when idlwave.el is loaded." make-obsolete-variable "use `with-eval-after-load' instead." "28.1"] 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 (#$ . 35629))
(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\\|||\\)\\>")
#@89 Like `dlet' but without warnings about non-prefixed var names.
(fn BINDERS &rest BODY)
(defalias 'idlwave--dlet '(macro . #[385 "\300\301\"\302\303BC\304BBE\207" [mapcar #[257 "\211:\203 \211@\207\207" [] 2 "\n\n(fn BINDER)"] with-suppressed-warnings lexical dlet] 8 (#$ . 36279)]))
(byte-code "\306\307\310\311#\312\307\313\314#\210\315\316\317\320\321\322\323\324\325\326 \327 D!\210\330\331\332 \"!\210\333 !
\f \n \257 !\210.\n\306\207" [class-arrows system-variables keyword-parameters structname structtag goto function-put idlwave--dlet lisp-indent-function 1 put edebug-form-spec let ("\\<\\(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+\\)[ ,]*" nil nil (1 font-lock-variable-name-face))) ("^[ ]*\\(@[^ \n]+\\)" (1 font-lock-string-face)) ("^[ ]*\\([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.")) label batch-files common-blocks pros-and-functions idlwave-default-font-lock-items idlwave-idl-keywords] 13)
#@14
(fn LIMIT)
(defalias 'idlwave-match-class-arrows #[257 "\205 \301\302\303#\205 \304\305\224\306\"\207" [idlwave-store-inquired-class re-search-forward "->" limit get-text-property 0 idlwave-class] 5 (#$ . 38342)])
#@51 Default expressions to highlight in IDLWAVE mode.
(defvar idlwave-font-lock-keywords idlwave-font-lock-keywords-2 (#$ . 38568))
(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))
#@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 "^[ ]*;" (#$ . 38940))
#@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\\)\\>" (#$ . 39161))
#@79 Regular expression to find the beginning of a unit.
The case does not matter.
(defconst idlwave-begin-unit-reg "^\\s-*\\(pro\\|function\\)\\>\\|\\`" (#$ . 39386))
#@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\\)\\>\\|\\'" (#$ . 39556))
#@47 Regular expression to match a continued line.
(defconst idlwave-continue-line-reg "\\<\\$" (#$ . 39839))
#@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\\)\\>" (#$ . 39951))
#@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")) (#$ . 40182))
#@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\\)\\>" (#$ . 40797))
#@48 Regular expression matching an IDL identifier.
(defconst idlwave-identifier "[a-zA-Z_][a-zA-Z0-9$_]*" (#$ . 41070))
#@51 Regular expression matching IDL system variables.
(defconst idlwave-sysvar (concat "!" idlwave-identifier) (#$ . 41192))
#@49 Regular expression matching IDL variable names.
(defconst idlwave-variable (concat idlwave-identifier "\\|" idlwave-sysvar) (#$ . 41319))
#@41 Regular expression matching IDL labels.
(defconst idlwave-label (concat idlwave-identifier ":") (#$ . 41463))
(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\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 "\\) *="] 19) (#$ . 41685))
#@35 IDL mode comment indent function.
(defvar idlwave-comment-indent-function 'comment-indent-function (#$ . 43163))
#@73 Character to be inserted for IDL comment indentation.
Normally a space.
(defvar idlwave-comment-indent-char -1 (#$ . 43282))
#@134 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 (#$ . 43414))
(defconst idlwave-mode-version "6.1_em22")
#@96 Create a function for abbrev hooks to call `idlwave-modify-abbrev' with args.
(fn &rest ARGS)
(defalias 'idlwave-keyword-abbrev #[128 "\300\301\"\207" [make-closure #[0 "\301\302\300\"\207" [V0 apply idlwave-modify-abbrev] 3]] 4 (#$ . 43649)])
#@72 Run an inferior IDL, with I/O through buffer `(idlwave-shell-buffer)'.
(autoload 'idlwave-shell "idlw-shell" '(#$ . 43901) 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" '(#$ . 44085) t)
#@38 Save and run buffer under the shell.
(autoload 'idlwave-shell-save-and-run "idlw-shell" '(#$ . 44222) t)
#@33 Set breakpoint in current line.
(autoload 'idlwave-shell-break-here "idlw-shell" '(#$ . 44333) t)
#@29 Compile and run the region.
(autoload 'idlwave-shell-run-region "idlw-shell" '(#$ . 44437) t)
(byte-code "\300\301\302 \"\207" [defalias idlwave-debug-map make-sparse-keymap] 3)
#@26 Keymap used in IDL mode.
(defvar idlwave-mode-map (byte-code "\301 \302\303\304#\210\302\305\304#\210\302\306\307#\210\302\310\307#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\324#\210\302\325\326#\210\302\327\330#\210\302\331\332#\210\302\333\334#\210\302\335\336#\210\302\337\340#\210\302\341\342#\210\302\343\344#\210\302\345\346#\210\302\347\350#\210\302\351\352#\210\302\353\354#\210\302\355\356#\210\302\357\360#\210\302\361\362#\210\302\363\364#\210\302\365\366#\210\302\367\370#\210<\203\n\203\n\371>\372\371\373!\"\302\374\375\203\312 \376\202\313 \377C\"!\201@ #\210\302\374\375\203\343 \201A \202\346 \201B C\"!\201C #\210\302\374\375\203\376 \201D \202\201E C\"!\201F #\266\302\201G \201@ #\210\302\201H \201C #\210\302\201I \201F #\210\302\201J \201K #\210\302\201L \201M #\210\302\201N \201O #\210\302\201P \201Q #\210\302\201R \201S #\210\302\201T \201U #\210\302\201V \201W #\210\302\201X \201Y #\210\302\201Z \201[ #\210\302\201\\ \201] #\210\302\201^ \201_ #\210\302\201` \201a #\210\302\201b \201c #\210\302\201d \201c #\210\302\201e \201c #\210\302\201f \201g #\210\302\201h \201i #\210\302\201j \201k #\210\207" [idlwave-shell-debug-modifiers 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 "" auto-fill-mode "\361" idlwave-fill-paragraph "\363" idlwave-edit-in-idlde "" idlwave-doc-header "
" idlwave-doc-modification "" idlwave-case "" idlwave-debug-map shift 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] 9) (#$ . 44621))
#@48 Syntax table in use in `idlwave-mode' buffers.
(defvar idlwave-mode-syntax-table (byte-code "\300 \301\302\303#\210\301\304\303#\210\301\305\303#\210\301\306\303#\210\301\307\303#\210\301\310\303#\210\301\311\303#\210\301\312\303#\210\301\313\303#\210\301\314\303#\210\301\315\316#\210\301\317\316#\210\301\320\303#\210\301\321\322#\210\301\323\324#\210\301\325\326#\210\301\327\322#\210\301\330\303#\210\301\331\332#\210\301\333\334#\210\301\335\334#\210\207" [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] 5) (#$ . 47420))
#@64 Syntax table that treats symbol characters as word characters.
(defvar idlwave-find-symbol-syntax-table (byte-code "\301!\302\303\304#\210\302\305\304#\210\302\306\304#\210\302\307\304#\210\207" [idlwave-mode-syntax-table copy-syntax-table modify-syntax-entry 36 "w" 95 33 46] 5) (#$ . 48061))
#@1366 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 one argument. 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 "," (lambda (_) (idlwave-surround 0 1)))
A minimum of 1 space before and after `=' (see `idlwave-expand-equal').
(idlwave-action-and-binding "=" (lambda (_) (idlwave-expand-equal -1 -1)))
Capitalize system variables - action only
(idlwave-action-and-binding idlwave-sysvar
(lambda (_) (capitalize-word 1) t))
(fn KEY CMD &optional SELECT)
(defalias 'idlwave-action-and-binding #[770 "\211\301=\2042 \211\203 \302\202 \303\304!\305J\306#\211\203$ \211\241\266\2022 B\211\262JBL\266\211\204= G\307U\202@ \211\310>\205L \311\312\313\"#\207" [idlwave-mode-map noaction idlwave-indent-action-table idlwave-indent-expand-table regexp-quote assoc equal 1 (noaction both) define-key make-closure #[0 "\301\302!\210\303\300!\203 \300\304!\207\305\300\306\"\207" [V0 self-insert-command 1 functionp nil eval t] 3 nil nil]] 9 (#$ . 48368)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\312\"\210\313\314\315\316\317\320%\207" [idlwave-action-and-binding "&" idlwave-custom-ampersand-surround "=" #[257 "\300\301\211\"\207" [idlwave-expand-equal -1] 4 "\n\n(fn _)"] "<" #[257 "\300\301\"\207" [idlwave-custom-ltgtr-surround nil] 4 "\n\n(fn A)"] ">" #[257 "\300\301\"\207" [idlwave-custom-ltgtr-surround t] 4 "\n\n(fn A)"] "," #[257 "\300\301\302\303$\207" [idlwave-surround 0 -1 1] 6 "\n\n(fn A)"] define-abbrev-table idlwave-mode-abbrev-table nil "Abbreviation table used for IDLWAVE mode." :enable-function #[0 "\300 ?\207" [idlwave-quoted] 1]] 6)
#@220 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.
(fn NAME EXPANSION HOOK &optional NOPREFIX TABLE)
(defalias 'idlwave-define-abbrev #[1283 "\303\206 \203 \202 PF\3041) \305\306\307\310\"\"0\202. \210\305\306\")\207" [idlwave-mode-abbrev-table idlwave-abbrev-start-char abbrevs-changed nil (error) apply define-abbrev append (0 t)] 12 (#$ . 50910)])
(byte-code "\3021 \303\304!\305 #0\210\202 \210\306\307\310\311#\210\306\312\310\313#\210\306\314\310\315#\210\306\316\310\317#\210\306\320\310\321#\210\306\322\310\323#\210\306\305\310\324#\210\306\325\310\326#\210\306\327\310\330#\210\306\331\332\333\334!#\210\306\335\336\333\337\340\"#\210\306\341\342\333\337\340\"#\210\306\343\344\333\334!#\210\306\345\346\333\334!#\210\306\347\350\333\334!#\210\306\351\352\333\334!#\210\306\353\354\333\334!#\210\306\355\356\333\334!#\210\306\357\360\333\334!#\210\306\361\362\333\337\340\"#\210\306\363\364\365#\210\306\366\367\365#\210\306\370\371\365#\210\306\372\373\365#\210\306\374\375\365#\210\306\376\377\365#\210\306\201@ \201A \365#\210\306\201B \201C \365#\210\306\201D \201E \365#\210\306\201F \201G \333\337\340\"#\210\306\201H \201I \333\337!#\210\306\201J \201K \333\334!#\210\306\201L \201M \333\334!#\210\306\201N \201O \333\337!#\210\306\201P \201Q \333\337\334\"#\210\306\201R \201S \333\337!#\210\306\201T \201U \333\337!#\210\306\201V \201W \333\337!#\210\306\201X \201Y \333\337!#\210\306\201Z \201[ \333\337!#\210\306\201\\ \201] \333\337!#\210\306\201^ \201_ \333\337!#\210\306\201` \201a \333\337!#\210\306\201b \201c \333\337!#\210\306\201d \201e \333\334!#\210\306\201f \201g \333\334!#\210\306\201h \201i \333\334!#\210\306\201j \201k \333\334!#\210\306\201l \201m \333\334!#\210\306\201n \201o \333\334!#\210\306\201p \201q \333\334!#\210\306\201r \201s \333\334!#\210\306\201t \201u \333\337\340\"#\210\306\201v \201w \333\337\340\"#\210\306\201x \201y \333\337!#\210\306\201z \201{ \333\201| !#\210\306\201} \201~ \333\201| !#\210\306\201 \201\200 \333\201\201 !#\210\306\201\202 \201\203 \333\201\201 !#\210\306\201\204 \201\205 \333\337!#\210\306\201\206 \201\207 \333\334!#\210\306\201\210 \201\211 \333\334!#\210\306\201\212 \201\213 \333\337!#\210\306\201\214 \201\215 \333\334!#\210\306\201\216 \201\217 \333\201| !#\210\306\201\220 \211\333\337\340\"\340$\210\306\336\211\333\337\340\"\340$\210\306\201\221 \211\333\337\340\"\340$\210\306\201\222 \211\333\337\340\"\340$\210\306\342\211\333\337\340\"\340$\210\306\201\223 \211\333\337\340\"\340$\210\306\201\224 \211\333\337\340\"\340$\210\306\362\211\333\337\340\"\340$\210\306\201\225 \211\201\226 \340$\210\306\364\211\201\226 \340$\210\306\371\211\201\226 \340$\210\306\373\211\201\226 \340$\210\306\201A \211\201\226 \340$\210\306\201C \211\201\226 \340$\210\306\367\211\201\226 \340$\210\306\201\227 \211\201\226 \340$\210\306\201E \211\201\226 \340$\210\306\201\230 \211\333\337\340\"\340$\210\306\201\231 \211\333\337\340\"\340$\210\306\201\232 \211\333\337\340\"\340$\210\306\201\233 \211\333\337\340\"\340$\210\306\201\234 \211\333\337\340\"\340$\210\306\201\235 \211\333\337\340\"\340$\210\306\201\236 \211\333\337\340\"\340$\210\306\201\237 \211\333\337\340\"\340$\210\306\201\240 \211\333\337\340\"\340$\210\306\201\241 \211\333\337\340\"\340$\210\306\201\242 \211\333\337\340\"\340$\210\306\201\243 \211\333\337\340\"\340$\210\306\201\244 \211\333\337\340\"\340$\210\306\201\245 \211\333\337\340\"\340$\210\306\201T \211\333\337\340\"\340$\210\306\201\246 \211\333\337\340\"\340$\210\306\201\247 \211\333\337\340\"\340$\210\306\201\250 \211\333\337\340\"\340$\210\306\201u \211\333\337\340\"\340$\210\306\201w \211\333\337\340\"\340$\210\306\201\251 \211\333\337\340\"\340$\210\306\201\252 \211\333\337\340\"\340$\207" [idlwave-abbrev-start-char idlwave-mode-syntax-table (error) modify-syntax-entry string-to-char "w" idlwave-define-abbrev "c" "" idlwave-case "sw" idlwave-switch "f" idlwave-for "fu" idlwave-function "pr" idlwave-procedure "r" idlwave-repeat idlwave-while "i" idlwave-if "elif" idlwave-elif "ap" "arg_present()" idlwave-keyword-abbrev 1 "b" "begin" 0 t "co" "common" "cb" "byte()" "cx" "fix()" "cl" "long()" "cf" "float()" "cs" "string()" "cc" "complex()" "cd" "double()" "e" "else" "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," "h" "help," "k" "keyword_set()" "n" "n_elements()" "on" "on_error," "oi" "on_ioerror," "ow" "openw," "or" "openr," "ou" "openu," "p" "print," "pt" "plot," "re" "read," "rf" "readf," "ru" "readu," "rt" "return" "sc" "strcompress()" "sn" "strlen()" "sl" "strlowcase()" "su" "strupcase()" "sm" "strmid()" "sp" "strpos()" "st" "strput()" "sr" "strtrim()" "t" "then" "u" "until" "wu" "writeu," "iap" "if arg_present() then" 6 "ik" "if keyword_set() then" "ine" "if n_elements() eq 0 then" 11 "inn" "if n_elements() ne 0 then" "np" "n_params()" "s" "size()" "wi" "widget_info()" "wc" "widget_control," "pv" "ptr_valid()" "ipv" "if ptr_valid() then" "and" "break" "case" "continue" "do" "end" idlwave-show-begin-check "endwhi" "eq" "for" "function" "ge" "goto" "gt" "if" "le" "lt" "mod" "ne" "not" "of" "on_ioerror" "pro" "repeat" "switch" "while" "xor"] 6)
(defvar idlwave-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [idlwave-mode-hook variable-documentation put "Hook run after 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] 4)
(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\311\312 !\210\306\301N\204- \302\306\301\303\313!#\210\302\310\314\315#\207" [idlwave-mode-map variable-documentation put purecopy "Keymap for `idlwave-mode'." boundp idlwave-mode-syntax-table definition-name idlwave-mode (lambda (#1=#:def-tmp-var) (defvar idlwave-mode-syntax-table #1#)) make-syntax-table "Syntax table for `idlwave-mode'." derived-mode-parent prog-mode] 5)
#@4826 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
\[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
-----
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 website at URL
`https://github.com/jdtsmith/idlwave'.
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 #[0 "\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\2035 \211\321 =\203; \322\f\323 \"\210\210\324 !\210\325\f!\210
@A\203R \326\327B\"\210\330A\306\331!\210\332\306C!\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\211$D\306\345!\210\346%\347E\306\350!\210\330(\306\351!\210\352)\306\353!\210\354+\306\355!\210\330-\306\356!\210\307.\306\357!\210\360/\361\362!\203\335 \3632\235\203\327 2\210\202\335 \3632B2\306\364!\210F4\306\365!\210\3665\306\367!\210\3707\306\371!\210\3729\306\373!\210\374;\375\376\311GH\337\377\330\257\"\210\201I \201J \201K \330\201L $\210\201I \201M \201N \330\201L $\210\201I \201O \201P \330\201L $\210\201I \201O \201Q \330\201L $\210\201R \210\201S \210\201T \210)\201U \201V !\207" [delay-mode-hooks major-mode mode-name idlwave-mode-map idlwave-mode-syntax-table idlwave-mode-abbrev-table 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 normal-auto-fill-function 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 ("\\.pro\\'" . "IDLTAGS") font-lock-defaults font-lock-mark-block-function idlwave-mark-subprogram font-lock-fontify-region-function idlwave-font-lock-fontify-region imenu-extract-index-name-function idlwave-unit-name imenu-prev-index-position-function idlwave-prev-index-position add-to-list hs-special-modes-alist idlwave-forward-block local-abbrev-table idlwave-startup-message idlwave-mode-version idlwave-comment-indent-function abbrev-mode comment-end idlwave-font-lock-defaults idlwave-begin-block-reg idlwave-end-block-reg 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 (#$ . 57190) nil])
(defvar idlwave-setup-done nil)
(defalias 'idlwave-setup #[0 "?\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])
#@71 Fontify continuation lines correctly.
(fn BEG END &optional VERBOSE)
(defalias 'idlwave-font-lock-fontify-region #[770 "\300\212b\210\301y\210\302 \211\262\203 \211b\210\303 \210`\262)\210\304#\207" [nil -1 idlwave-is-continuation-line idlwave-beginning-of-statement font-lock-default-fontify-region] 7 (#$ . 64985)])
#@43 Insert TAB in buffer in current position.
(defalias 'idlwave-hard-tab #[0 "\300c\207" [" "] 1 (#$ . 65317) nil])
#@157 If non-nil, a function called from `post-command-hook'.
It is evaluated in the Lisp function `idlwave-command-hook' which is
placed in `post-command-hook'.
(defvar idlwave--command-function nil (#$ . 65437))
#@148 Command run after every command.
Evaluates a non-nil value of the *variable* `idlwave--command-function' and
sets the variable to zero afterwards.
(defalias 'idlwave-command-hook #[0 "\205 \3011 \302 0\207\303\304\"\210\302\262\207" [idlwave--command-function (debug error) nil message "idlwave-command-hook: %S"] 4 (#$ . 65652)])
#@541 Tweak the abbrev we just expanded.
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.
(fn ARG &optional RESERVED)
(defalias 'idlwave-modify-abbrev #[513 "\211\203 \203 \305 `\"\210\202' \n\306=\203 \307 `\"\210\202' \n\203' \305 `\"\210 \2036 \310V\2036 \311\312\"\313\207" [idlwave-reserved-word-upcase last-abbrev-location idlwave-abbrev-change-case idlwave-abbrev-move idlwave--command-function upcase-region down downcase-region 0 make-closure #[0 "\300T\206 \301[u\207" [V0 1] 1] t] 5 (#$ . 65997)])
#@55 Return t if point is inside a comment, nil otherwise.
(defalias 'idlwave-in-comment #[0 "\212`\300 \205\n \211`V\262)\207" [idlwave-goto-comment] 3 (#$ . 66942)])
#@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 #[0 "\301 \302 \303\304 \210\305\306#\262\211\203\" \307 \203\" \305\306#\262\202 \310!\210\211\2054 \307 ?\2054 \311u\210`\207" [comment-start point-at-eol match-data nil beginning-of-line search-forward lim idlwave-in-quote store-match-data -1] 7 (#$ . 67113)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias idlwave-region-active-p use-region-p nil make-obsolete "28.1"] 4)
#@66 Insert quote and show matching quote if this is end of a string.
(defalias 'idlwave-show-matching-quote #[0 "\301 \203 \302 \204 fc\210=\205 \212b\210\303\304!)\207\211c\207" [last-command-event idlwave-in-quote idlwave-in-comment sit-for 1] 5 (#$ . 67751) 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 #[0 "\212\300\301!\210\302u\210\303\304!)\205 \305 \207" [backward-word-strictly 1 -1 looking-at "[ \n\f]" idlwave-show-begin] 2 (#$ . 68031)])
#@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 #[0 "\304 \305!\306 \307\211\211\211 \203 \310 \210\311!\312\313\314\"\205\244 \n\205\244 \212b\210\315\316\317\"\210`\262\315\320\317\"\210`\262V\203@ \262b\210\321\307x\210`{\262b\210\322 A\211\262\205\243 \211?\206\243 \227\227\230\203k \323\320!\202\243 \227\324\230\203\227 \203\221 \212b\210\325u\210\326\230\203\211 \211\226\202\212 \211c\210\327\330!\210)\323\320!\202\243 \331 \210\332\333#\210\323\320!)\207" [last-abbrev-location idlwave-reindent-end idlwave-show-block idlwave-expand-generic-end point-marker copy-marker point-at-eol nil idlwave-indent-line marker-position idlwave-modify-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\"?"] 11 (#$ . 68336)])
(defalias 'idlwave-block-master #[0 "\303\212\304\305!\203 \306\307\310!\227 \"\202D \304\311!\203C \212\312 \210`)\313\314\303#\203+ \315\202> \313\n\303#\203= \306\307\316!\227 \"\202> \317\262\202D \320*\207" [case-fold-search idlwave-block-matches 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] 5])
#@61 Terminate the current block with the correct END statement.
(defalias 'idlwave-close-block #[0 "\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 (#$ . 69793) nil])
#@85 Surround &, leaving room for && (which surround as well).
(fn &optional IS-ACTION)
(defalias 'idlwave-custom-ampersand-surround #[256 "`\300Zf`f\301=\301=\203 \300\202 \302?\205( \303\304\204% \205& \304#\207" [2 38 1 idlwave-surround -1] 10 (#$ . 70074)])
#@107 Surround > and < by blanks, leaving room for >= and <=, and considering ->.
(fn GTR &optional IS-ACTION)
(defalias 'idlwave-custom-ltgtr-surround #[513 "`\300Zf`f\205
\301=\211\203 \300\202 \302\303=?\205+ \304\305\204( \205) \305#\207" [2 45 1 61 idlwave-surround -1] 10 (#$ . 70349)])
#@560 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
(fn &optional BEFORE AFTER LENGTH IS-ACTION)
(defalias 'idlwave-surround #[1024 "\205W \303 ?\205W \206 \304\211\206 \304[u\210\214`\305\306x\210n\2033 \307\310 !\210`X\2030 `}\210\211b\210\311!\266\305\306w\210)\211u\210\311!\210`Sf\312=\205U i V\205U \n \262\207" [idlwave-surround-by-blank fill-column auto-fill-function idlwave-quoted 1 " " nil move-to-column idlwave-calculate-indent idlwave-make-space 32] 8 (#$ . 70654)])
#@444 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).
(fn N)
(defalias 'idlwave-make-space #[257 "\211\250\2056 \300\301x\210i`\300\301w\210i\302 \210\303V\203$ \304\\!\210\\b\207\303W\2054 \304[\"\210Zb\266\203\207" [" " nil delete-horizontal-space 0 idlwave-indent-to] 7 (#$ . 71616)])
#@60 Insert a newline and indent the current and previous line.
(defalias 'idlwave-newline #[0 "\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 (#$ . 72303) nil])
#@64 Compute indent for the beginning of the IDL comment delimiter.
(defalias 'idlwave-comment-hook #[0 "\304!\204 \304 \206\f \305!\203 i\207\304\n!\203/ \212\306\307x\210n)\203- \310 \211<\203, \211@\207\207i\207\306\307x\210n\203; \311\202= iT ]\207" [idlwave-no-change-comment idlwave-begin-line-comment idlwave-code-comment comment-column looking-at "^;" " " nil idlwave-calculate-indent 0] 2 (#$ . 72649)])
#@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 #[0 "\203 \303 \210\304\305 \204S \306 \211\262\203? \2030 \211f\211\262\307\n\261\210\310u\210\311 \210\312u\210\202V \313 \210\314\315!\210\316\n\261\210\202V `Sf\317>\204J \316c\210\nc\210\311 \210\202V \320 \210d`Z\262\310y\210\321 \210dZb\210\321 \207" [abbrev-mode 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] 5 (#$ . 73068) nil])
#@121 Move point to the beginning of the current program unit.
If NOMARK is non-nil, do not push mark.
(fn &optional NOMARK)
(defalias 'idlwave-beginning-of-subprogram #[256 "\301\302#\207" [idlwave-begin-unit-reg idlwave-find-key -1] 5 (#$ . 73941) nil])
#@114 Move point to the start of the next program unit.
If NOMARK is non-nil, do not push mark.
(fn &optional NOMARK)
(defalias 'idlwave-end-of-subprogram #[256 "\301 \210\302\303#\207" [idlwave-end-unit-reg idlwave-end-of-statement idlwave-find-key 1] 5 (#$ . 74201) nil])
#@29 Mark current IDL statement.
(defalias 'idlwave-mark-statement #[0 "\300 \210`\301 \210\302\303\304#\207" [idlwave-end-of-statement idlwave-beginning-of-statement push-mark nil t] 5 (#$ . 74478) nil])
#@24 Mark containing block.
(defalias 'idlwave-mark-block #[0 "\300 \210\301\302!\210\300 \210`\303 \210\304 \210\305\306\307#\207" [idlwave-end-of-statement idlwave-backward-up-block -1 idlwave-backward-block idlwave-beginning-of-statement push-mark nil t] 5 (#$ . 74685) nil])
#@71 Put mark at beginning of program, point at end.
The marks are pushed.
(defalias 'idlwave-mark-subprogram #[0 "\300 \210\301 \210`\302 \210\303\304\305#\266\306 \207" [idlwave-end-of-statement idlwave-beginning-of-subprogram idlwave-forward-block push-mark nil t exchange-point-and-mark] 5 (#$ . 74966) nil])
#@138 Move to beginning of enclosing block if prefix ARG >= 0.
If prefix ARG < 0 then move forward to enclosing block end.
(fn &optional ARG)
(defalias 'idlwave-backward-up-block #[256 "\300[\301\"\207" [idlwave-block-jump-out nomark] 4 (#$ . 75283) "p"])
#@43 Go to the beginning of the current block.
(defalias 'idlwave-beginning-of-block #[0 "\300\301\302\"\210\303\304!\207" [idlwave-block-jump-out -1 nomark forward-word-strictly 1] 3 (#$ . 75541) nil])
#@43 Go to the beginning of the current block.
(defalias 'idlwave-end-of-block #[0 "\300\301\302\"\210\303\301!\207" [idlwave-block-jump-out 1 nomark backward-word-strictly] 3 (#$ . 75745) nil])
#@52 Move across next nested block.
(fn &optional ARG)
(defalias 'idlwave-forward-block #[256 "\211\206 \300\301!\205 \302\303\"\207" [1 idlwave-down-block idlwave-block-jump-out nomark] 5 (#$ . 75941) nil])
#@45 Move backward across previous nested block.
(defalias 'idlwave-backward-block #[0 "\300\301!\205\n \302\301\303\"\207" [idlwave-down-block -1 idlwave-block-jump-out nomark] 3 (#$ . 76155) nil])
#@123 Go down a block.
With ARG: ARG >= 0 go forwards, ARG < 0 go backwards.
Returns non-nil if successful.
(fn &optional ARG)
(defalias 'idlwave-down-block #[256 "\302\303W\203& \212\304\305\306\"\210`)\307\305\306$\211\262\203 \310 \266\207\311\312!\266\207\212\304\313\306\"\210`)\307 \313\306$\211\262\203? \314 \266\207\311\315!\266\207" [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."] 8 (#$ . 76356) "p"])
#@82 Put point at beginning of doc library header, mark at end.
The marks are pushed.
(defalias 'idlwave-mark-doclib #[0 "\302`db\210\303\302\304#\205. \305 \210`\262\306 \302\304#\203( \307y\210\310\302\304#\210\311\312!\210\311\313!\210\211b\207" [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."] 6 (#$ . 77008) nil])
(defalias 'idlwave-current-routine-fullname #[0 "\300 \301\3028@\"\207" [idlwave-current-routine idlwave-make-full-name 2] 4])
#@46 Return (NAME TYPE CLASS) of current routine.
(defalias 'idlwave-current-routine #[0 "\300 \210\212\301\302!\210\303\304!\205- \305\306!\227\307\230\203 \310\202 \311\312\305\313!!\314\305\315!\"\211E\266\203)\207" [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] 6 (#$ . 77621)])
#@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 #[0 "\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 (#$ . 78115) 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 #[0 "\302\303y\304U\204\n \305\207\306!\206\" \306\307!\206\" \306\310 \307Q!\206\" \306\311!\211\262\203/ \303y\304U\204\n \212\303y\210\312 )\203@ \303y\304U\204/ \207" [idlwave-comment-line-start-skip idlwave-label nil -1 0 t looking-at "[ ]*$" "[ ]*" "^@" idlwave-is-continuation-line] 5 (#$ . 78626) 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 #[0 "\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 (#$ . 79165) 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 #[0 "\300 \203\f \301y\302U\204 \303\210`\207" [idlwave-is-continuation-line 1 0 nil] 2 (#$ . 79503) 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 #[0 "\302\303 \210\304y\305U\203) \306!\206# \306\307!\206# \306\310 \307Q!\206# \306\311!\211\262\204 \207" [idlwave-comment-line-start-skip idlwave-label nil idlwave-end-of-statement 1 0 looking-at "[ ]*$" "[ ]*" "^@"] 5 (#$ . 79776) nil])
#@71 Skip past multiple commands on a line (with `&').
(fn &optional LIM)
(defalias 'idlwave-skip-multi-commands #[256 "`\300\301\302#\203$ \303\225b\210\304 \203 \211b\210\202$ `\305Zf\306=\203$ \211b\210`\207" [re-search-forward ".*&" t 0 idlwave-quoted 2 38] 6 (#$ . 80212)])
#@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 #[0 "`\212\300 \210`)\301\302\303\304$\211\2032 \305\"@\306U\2032 \307\310{\"\2042 \311\312{\"\2042 \313u\210`\207b\210\313\207" [idlwave-end-of-statement idlwave-find-key ":" 1 nomark parse-partial-sexp 0 string-search "?" string-match "^::" nil] 7 (#$ . 80496)])
#@343 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.
(fn &optional PRE)
(defalias 'idlwave-start-of-substatement #[256 "`\300 \301\302\211\211\303 \210\304 \210`W\203 \305!\210`\262`X\203y m\204y `\262\306 @\211\262AA@\262@\307=\203@ T\262\203U \310\311\312$\203U \301\225b\210\202 \301V\203p \310\313\311\312$\203p S\262\301\225b\210\202 \301\262\314 \210\202 \203\201 \211b\210\315\316!\203\213 \317\320!\210`\207" [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] 12 (#$ . 80943)])
#@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 #[0 "\212\302\303!\203
\304y\210\202 \305\306w\210\307\302@A@!\204% \211A\211\262\204 \211\205. \310\311\225\")\262)\207" [idlwave-statement-match case-fold-search looking-at "[ ]*\\$" 1 " " nil t append 0] 4 (#$ . 81955)])
#@965 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'.
(fn &optional BEFORE AFTER IS-ACTION)
(defalias 'idlwave-expand-equal #[768 "\205\201 \303\212\304\305u\210\306\307\310\304#\204 \306\311\310\304#\203% \312\303!GT\262\2024 \306\313\310\304#\2034 \312\303!GT\262*\n\304=\203C \314#\202 \212\315\304!\210\316 )\212\317\310x\210\320\321 8)\211\322>\204c @@\323>\203v \n\204p \314\324\211\"\266\202\202 \266\304\202 \314#\266\202\262\207" [idlwave-surround-by-blank case-fold-search idlwave-pad-keyword 1 t -1 re-search-backward "\\(##\\|\\*\\|\\+\\|-\\|/\\|<\\|>\\|\\^\\)\\=" nil "\\(#\\)\\=" match-string "\\s-\\(AND\\|EQ\\|GE\\|GT\\|LE\\|LT\\|MOD\\|NE\\|OR\\|XOR\\)\\=" idlwave-surround idlwave-start-of-substatement idlwave-statement-type "= " 2 idlwave-where (function-keyword procedure-keyword) (for pdef) 0] 10 (#$ . 82568)])
#@129 Call `idlwave-indent-line' and do expand actions.
With prefix ARG non-nil, indent the entire sub-statement.
(fn &optional ARG)
(defalias 'idlwave-indent-and-action #[256 "\212\203( \303\304\305`\306Z]\307#\203( \310\311!\203( \312\225b\210 \203% \313 \210\202( \314 \210)\211\2046 \n\2036 \n\262\315\211\203= \316 \207\317\307!\207" [idlwave-expand-generic-end abbrev-mode 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] 6 (#$ . 84300) "p"])
#@241 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.
(fn &optional EXPAND)
(defalias 'idlwave-indent-line #[256 "\212\306\307x\210n)\203 \306\307w\210\310 \212\311 \210\312!\203& \306\307w\210\313\314 !\210\202c \2033 \2033 \315\316\n\"\210 \203< \315\316 \"\210\311 \210\312\317\f\320Q!\204S \312\321!\204S \313\322 !\210\307\210\323 \203c \324 S \325 \210))\211b\210\211\307\211\223\207" [idlwave-comment-line-start-skip idlwave-do-actions idlwave-indent-expand-table idlwave-indent-action-table idlwave-label fill-column " " 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 frame-width indent-for-comment] 6 (#$ . 84899) nil])
#@477 Perform an action repeatedly on a line.
ACTION is a list (REG . FUNC). REG is a regular expression. FUNC is
either a function which will be called with one argument `is-action' 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.
(fn ACTION)
(defalias 'idlwave-do-action #[257 "\211@A\300 \210\301!\205% \302!\203 \211\303!\210\202 \304\305\306\"\307\"\210\202 \207" [beginning-of-line idlwave-look-at functionp is-action eval append ('is-action) t] 7 (#$ . 85842)])
#@112 Indent from point with spaces until column COL.
Inserts space before markers at point.
(fn COL &optional MIN)
(defalias 'idlwave-indent-to #[513 "\211\204 \300\262\301\302iZ]\303\"!\207" [0 insert-before-markers make-string 32] 7 (#$ . 86557)])
#@156 Indent the current line to column COL.
Indents such that first non-whitespace character is at column COL
Inserts spaces before markers at point.
(fn COL)
(defalias 'idlwave-indent-left-margin #[257 "\212\300 \210\301 \210\302!)\207" [beginning-of-line delete-horizontal-space idlwave-indent-to] 3 (#$ . 86814)])
#@43 Indent program unit which contains point.
(defalias 'idlwave-indent-subprogram #[0 "\212\300 \210\301 \210`\302 \210\303\304!\210\305`\306#\266\303\307!)\207" [idlwave-end-of-statement idlwave-beginning-of-subprogram idlwave-forward-block message "Indenting subprogram..." indent-region nil "Indenting subprogram...done."] 5 (#$ . 87134) nil])
#@61 Indent current statement, including all continuation lines.
(defalias 'idlwave-indent-statement #[0 "\212\300 \210`\301 \210\302`\303#\262)\207" [idlwave-beginning-of-statement idlwave-end-of-statement indent-region nil] 5 (#$ . 87486) nil])
#@62 Return appropriate indentation for current line as IDL code.
(defalias 'idlwave-calculate-indent #[0 "\212\306 \210\307!\203 \310\202q \212\311y\310U\205 \312 )\203! \313 \202q \314\212\315 `\262\203/ \310\202a \307\316\"\203= \317 \\\202a \307\n\316\"\203K \320 \\\202a \307\f\316\"\203_ \211b\210\321\311\322\"\210\320 \202a \317 )\307\f!\203n \211
\\\202o \211\266\202)\207" [idlwave-begin-unit-reg idlwave-main-block-indent idlwave-begin-block-reg idlwave-block-indent idlwave-end-block-reg idlwave-end-offset 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] 4 (#$ . 87736)])
#@177 Calculate the continuation indent inside a paren group.
Returns a cons-cell with (open . indent), where open is the
location of the open paren.
(fn BEG-REG END-REG CLOSE-EXP)
(defalias 'idlwave-calculate-paren-indent #[771 "\302\"A@\211\2054 \211b\210\211\203 \303 \\\2023 \203! i\2023 \304u\210\305\306!\203. \307\2023 \310\307w\210iB\207" [idlwave-indent-parens-nested idlwave-continuation-indent parse-partial-sexp idlwave-current-indent 1 looking-at "[ $]*\\(;.*\\)?$" nil " "] 7 (#$ . 88513)])
#@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 #[0 "\212\306\307 \210`\212\310 \210`)\311\312!\210\313 =\203 \211b\202 `\314! \\\315\211\316\315\211b\210\3172M @\211\262\205L \320A!\203E \321\317@\"\210A\262\2020 0\211\262\205Z \322\323\324 $\266\203\203s \320\325!\203n \326 \n \\Z\202\215\326 \202\215\327\315\3172\247 b\210\323y\330U\204\211 \321\317\315\"\210@\211\262\205\246 \320\331\332Q!\203\237 \321\317\306\"\210A\262\202\211 0\266\202\203\263 \326 \\\202\215\211b\210\333\315w\210\320\334!\315\3352\365 \336#\211\262\205\364 \f\204\347
\204\347 \211A\203\347 \211AZ-W\203\355 \321\335A\"\210\211@\262\202\303 0\266\203\211\262\203\211\202\215-\330V\203\214b\210\337\340!\204 \337\341!\210\320\342!\2034\330\225b\210\343 \344\345\"\216\320\346!)\262?\205oi\202o\3472Q\320\350!\205P\330\225b\210\351!\2048\321\347\306\"\210\20280\205o\352 \206j\320\346!\206j\212b\210\353 @@)\354=?\205oi\211\262\203\214Z-W\203\214\211\203\210 \\\202\215\202\215)\266\206)\207" [case-fold-search idlwave-continuation-indent idlwave-block-indent idlwave-end-offset idlwave-indent-to-open-paren idlwave-indent-parens-nested 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 looking-at throw idlwave-find-key -1 nomark "end" idlwave-current-indent ("\\<then\\>" "\\<do\\>" "\\<repeat\\>" "\\<else\\>") 0 ".*" "[ ]*\\$[ ]*\\(;.*\\)?$" " " "\\s)" loop idlwave-calculate-paren-indent idlwave-look-at "&" "^[ ]*\\(pro\\|function\\)" "[ ]*\\([a-zA-Z0-9.$_]+[ ]*->[ ]*\\)?[a-zA-Z][:a-zA-Z0-9$_]*[ ]*\\(,\\)[ ]*" match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] "[ $]*\\(;.*\\)?$" assign "[^=\n
]*\\(=\\)[ ]*" idlwave-what-function idlwave-in-quote idlwave-statement-type for idlwave-max-extra-continuation-indent] 14 (#$ . 89028)])
#@482 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.
(fn KEY-RE &optional DIR NOMARK LIMIT)
(defalias 'idlwave-find-key #[1025 "\206 \302\262\303\302V\203 \304\202 \305\306\307 p\310\311#\216\312 !\210\212\3132b \303#\205a \314 \204C \315\313\302\224\211\262\"\210\202( \302V\203N m\204Y \302W\203( o\203( \315\313\306\"\210\202( 0\210*\266\211\205u \204q \316 \210\211b\210\211)\207" [case-fold-search idlwave-find-symbol-syntax-table 0 t re-search-forward re-search-backward nil syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table exit idlwave-quoted throw push-mark] 13 (#$ . 91519)])
#@494 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.
(fn &optional DIR NOMARK)
(defalias 'idlwave-block-jump-out #[512 "\204 \305\262`\306\305Y\203 d\202 e\305Y\203 \202 \n\307 \310\nQ\212\305W\2038 \311 \306$\202C \307\210\311\f\306$)\206H \305Y\203R \307\210\311 \306$\211\262\203\206 \203\206 \312!\203\206 \305Y\203t \313\314!\210\315\306\"\210\311 \306$\262\202_ \204\220 \316!\210\204\231 \211b\202\243 \305Y\205\243 \313\314!)\207" [case-fold-search idlwave-begin-block-reg idlwave-end-block-reg idlwave-begin-unit-reg idlwave-end-unit-reg 0 t nil "\\|" idlwave-find-key looking-at forward-word-strictly 1 idlwave-block-jump-out push-mark] 13 (#$ . 92575) "P"])
#@70 The minimum indent in the current statement.
(fn &optional END-REG)
(defalias 'idlwave-min-current-statement-indent #[256 "\300 \210\301 \204 \302 \207\302 \303\304y\305U\2039 \306 \211\262\204\" \301 \2039 \203, `W\2039 \211\204 \302 ^\262\202 \211\204G \203I `Y\203I \207\302 ^\207" [idlwave-beginning-of-statement idlwave-is-continuation-line idlwave-current-indent nil 1 0 idlwave-is-comment-or-empty-line] 5 (#$ . 93711)])
#@146 Return indentation of the current statement.
If in a statement, moves to beginning of statement before finding indent.
(fn &optional LAST-LINE)
(defalias 'idlwave-current-statement-indent #[256 "\211\203\n \300 \210\202
\301 \210\302 \207" [idlwave-end-of-statement idlwave-beginning-of-statement idlwave-current-indent] 2 (#$ . 94159)])
#@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 #[0 "\212\300 \210\301\302w\210l\203 \303\202 i)\207" [beginning-of-line " " nil 0] 2 (#$ . 94506)])
#@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 #[0 "\300\212\301\302!\206+ \3032+ \304\305!\205* \306y\307=\205* \301\302!\211\262\203\f \310\303\"\210\202\f 0)\207" [nil idlwave-look-at "\\<\\$" loop looking-at "^[ ]*\\(;.*\\)?$" -1 0 throw] 4 (#$ . 94785)])
#@45 Test if the current line is a comment line.
(defalias 'idlwave-is-comment-line #[0 "\212\300\301!\210\302\303!)\207" [beginning-of-line 1 looking-at "[ ]*;"] 2 (#$ . 95194)])
#@45 Test if the current line is a comment line.
(defalias 'idlwave-is-comment-or-empty-line #[0 "\212\300\301!\210\302\303!)\207" [beginning-of-line 1 looking-at "[ ]*[;\n]"] 2 (#$ . 95376)])
#@573 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.
(fn REGEXP &optional CONT BEG)
(defalias 'idlwave-look-at #[769 "`\302\212\203
\303 \210\202 \304\210`)\304\305 p\306\307#\216\310 !\210\203* \311 \210\312 \302#\211\262\203; \313 \204* )\266\211\204E b\210)\207" [case-fold-search idlwave-find-symbol-syntax-table t idlwave-end-of-statement nil syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table idlwave-beginning-of-statement re-search-forward idlwave-quoted] 13 (#$ . 95572)])
#@753 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.
(fn &optional NOHANG)
(defalias 'idlwave-fill-paragraph #[256 "\212\305 \210\306\307w\210\310!)\205{\311\307\211\211\211\211\211\211\211\211\212\312 \210`\262)\212\313 \210`\262)\314\"\210`\262\305 \210`\262\315\316\317Q\320 \321#\210i\262 \322\323 `{!\211\324P\262b\210\310!\203j \310\n!\204j o\204j \325y\210\202S `U\204s \326y\210`\262b\210\310!\203\220 \310\n!\204\220 m\204\220 \326y\210\202y \305 \210\310!\203\240 \310\n!\203\243 \325y\210\307\210m\203\260 \327c\210\325u\210d`ZS\262\n\204 \203\212b\210\330 )\211\262\203\262\n\305 \210`V\203\"\315\f\320 \321#\210 iZ\211\262\331V\203 `Y\203\371 \\\262\332\333\"c\210\325y\210\202\322 `V\203\"\305 \210 \315\f\320 \321#\210i^\262\n\325y\210\202 \332 Z\333\"P\315\f\320 \321#\210i\n]\262b\210\212\211\\S{\262\334\211\\S\333\335\307%\210\336dZ\337 \307$\210\211\\S|\210b\210c\210)n\203v\306P\307w\210\307\211\266\212\207" [comment-start fill-prefix paragraph-separate idlwave-hanging-indent comment-start-skip 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] 17 (#$ . 96615) "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 #[0 "\203 \212\302\210\303 \304 \305#\205 i 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 (#$ . 98708)])
#@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 #[0 "iX?\205\326 \203 \212\306 \210\307\n!)\205\326 \310\311 \210\310\312\313 \205& \205& \314 \315 \210+\212\316\210\311 \210)\212\306 \210\307\n!)\203o !\205\324 d`Z\212\317y\210\320 )\211\205j \306 \210\321\"\322 \323#\210\324 \210\325!\210dZb\266\202\202\324 \212\316\210\326 )\203\230 \212\306 \210\327\310w\210\330\212\317y\210\331 \332\310w\210`{)\261\210)\311 \202\324 \212\316\210\313 \211\262\203\257 \203\257 \330f\333\261\210\334c\210)\211\203\322 \203\313 \212\306 \210\327\310w\210\211fc\210)\202\322 \335 \210\336\337!\210\311 \262\207" [fill-column idlwave-fill-comment-line-only idlwave-comment-line-start-skip idlwave-auto-fill-split-string fill-nobreak-predicate paragraph-separate beginning-of-line looking-at nil idlwave-indent-line "." idlwave-in-quote #[0 "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." idlwave-do-actions idlwave-hanging-indent comment-start-skip] 7 (#$ . 99329)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias idlwave-auto-fill-mode auto-fill-mode nil make-obsolete "28.1"] 4)
#@237 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.
(fn &optional NOMARK)
(defalias 'idlwave-doc-header #[256 "\211\204 \302 \210\203 eb\210\202- \303\210\304 \210\305 \210\306\307!\203- \310 \210\311y\312V\203- \313c\210` \203K @\203? \314 @!\210\202K A@;\203K A@c\210\211b\207" [idlwave-header-to-beginning-of-file 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] 4 (#$ . 100945) "P"])
#@39 Default timestamp insertion function.
(defalias 'idlwave-default-insert-timestamp #[0 "\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 (#$ . 101644)])
#@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 #[0 "\304 \210\305\211\306\305\307#\204 eb\210\310\305\307#\203] \311\224\211\262\203] \310 \305\307#\203] \311\225\211\262\203] b\210\310\n\312P\307#\203C \305\210\202V \211b\210\313\210\314 \314\261\210 \315\n\312\261\210\316c\210\317\320!\207\321\322!\207" [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"] 6 (#$ . 102016) nil])
#@111 Expand each abbrev occurrence in the region.
Calling from a program, arguments are START END.
(fn START END)
(defalias 'idlwave-expand-region-abbrevs #[514 "\212^b\210\302\211\303\304#+\207" [idlwave-abbrev-move idlwave-show-block nil expand-region-abbrevs noquery] 6 (#$ . 102929) "r"])
#@76 Return t if point is in a comment or quoted string.
Returns nil otherwise.
(defalias 'idlwave-quoted #[0 "\300 \204\n \301 \205 \302\207" [idlwave-in-comment idlwave-in-quote t] 1 (#$ . 103230)])
#@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 #[0 "\212`\300 \301 \210``\302 \303\211W\203n \304\305\306#\203e \307\224Tb\210`S\262\310h!\262\311!\203: `\262\312u\210\202
\313\306#\262\311!\203V \312u\210\313\306#\262\202B \211\203_ `S\202` `\262\202
`\262`\262\202
\314!\210V\205z \266\207)\207" [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] 11 (#$ . 103434)])
#@90 Determine if the character after point is a pointer dereference *.
(fn &optional LIMIT)
(defalias 'idlwave-is-pointer-dereference #[256 "\301f\302=\205 \303 ?\205 \212\301u\210\304\305\306Q\307#)\207" [idlwave-idl-keywords nil 42 idlwave-in-quote re-search-backward "\\(" "\\|[-[(*+/=,^><]\\)\\s-*\\*" t] 5 (#$ . 104150)])
#@645 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.
(fn S1 S2 &optional PROMPT NOINDENT)
(defalias 'idlwave-template #[1026 "\304\305!\203 \306=\203 `\232\203 \nc\207\307\310!\207 \311=\203* \227\262\227\262\2026 \2036 \226\262\226\262\312 \313\314\315!\204C \316\317!\210c\210\212c\210`\262)\204X \320\313#\210;\205a \321\322\"\207" [this-command last-abbrev-location last-abbrev-text idlwave-abbrev-change-case 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"] 10 (#$ . 104485)])
#@84 Make STRING have the case required by `idlwave-reserved-word-upcase'.
(fn STRING)
(defalias 'idlwave-rw-case #[257 "\203 \211\226\207\207" [idlwave-reserved-word-upcase] 2 (#$ . 105675)])
#@35 Build skeleton IDL if-else block.
(defalias 'idlwave-elif #[0 "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "if" " then begin\n\nendif else begin\n\nendelse" "Condition expression"] 4 (#$ . 105872) nil])
#@36 Build skeleton IDL case statement.
(defalias 'idlwave-case #[0 "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "case" " of\n\nendcase" "Selector expression"] 4 (#$ . 106104) nil])
#@38 Build skeleton IDL switch statement.
(defalias 'idlwave-switch #[0 "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "switch" " of\n\nendswitch" "Selector expression"] 4 (#$ . 106310) nil])
#@36 Build skeleton IDL loop statement.
(defalias 'idlwave-for #[0 "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "for" " do begin\n\nendfor" "Loop expression"] 4 (#$ . 106524) nil])
#@34 Build skeleton IDL if statement.
(defalias 'idlwave-if #[0 "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "if" " then begin\n\nendif" "Scalar logical expression"] 4 (#$ . 106729) nil])
(defalias 'idlwave-procedure #[0 "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "pro" "\n\nreturn\nend" "Procedure name"] 4 nil nil])
(defalias 'idlwave-function #[0 "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "function" "\n\nreturn\nend" "Function name"] 4 nil nil])
(defalias 'idlwave-repeat #[0 "\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 #[0 "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "while" " do begin\n\nendwhile" "Entry condition"] 4 nil nil])
#@158 Return a list of substrings of STRING which are separated by PATTERN.
If PATTERN is omitted, it defaults to "[ \f\t\n\r\v]+".
(fn STRING &optional PATTERN)
(defalias 'idlwave-split-string #[513 "\211\204 \300\262\301\302\303#\203! \302\224OB\262\302\225\262\202 \301OB\237\207" ["[ \f \n
]+" nil 0 string-match] 8 (#$ . 107577)])
#@43
(fn STRING REPLACE_STRING REPLACE_WITH)
(defalias 'idlwave-replace-string #[771 "\300G\301\302\303#\211\262\203% OQ\262\300\225\262\202 OP\211\262\207" [0 "" nil string-match] 11 (#$ . 107929)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias idlwave-get-buffer-visiting find-buffer-visiting nil make-obsolete "28.1"] 4)
#@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 (#$ . 108301))
#@27
(fn FILE &optional WHY)
(defalias 'idlwave-find-file-noselect #[513 "\301!\206$ \302!\203! \211B\211\235\203 \266\202! \211B\210\211\262\207" [idlwave-outlawed-buffers find-buffer-visiting find-file-noselect] 6 (#$ . 108490)])
#@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 #[0 "\204 \301\302!\207\303\304\305\306\307!\306\310!#!\210\311 \211\312\267\202( \313\307!\207\313\310!\207\313\314!\207\301\315!\207" [idlwave-outlawed-buffers 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 #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (102 28 6 28 115 32 19 32 97 36 1 36)) idlwave-do-kill-autoloaded-buffers t "Abort"] 6 (#$ . 108737) nil])
#@51 How many outlawed buffers have tag TAG?
(fn TAG)
(defalias 'idlwave-count-outlawed-buffers #[257 "\301\302\303\304\305\"\"\"G\207" [idlwave-outlawed-buffers delq nil mapcar make-closure #[257 "\211A\300=\207" [V0] 3 "\n\n(fn X)"]] 7 (#$ . 109784)])
#@77 Kill all buffers pulled up by IDLWAVE matching REASONS.
(fn &rest REASONS)
(defalias 'idlwave-do-kill-autoloaded-buffers #[128 "\301!\302\303\211A\262\242\211\262\203D \304@!\203< \305>\204% \211A>\203 \306@!\203 T\211\262\203 \307\"\202 \307\"\202 \310\311\211\312U\203Q \313\202R \314#\207" [idlwave-outlawed-buffers copy-sequence 0 nil buffer-live-p t kill-buffer delq message "%d buffer%s killed" 1 "" "s"] 9 (#$ . 110042)])
#@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 #[0 "p\211\236\211\203
\301\"\302\303\304\305#\207" [idlwave-outlawed-buffers delq remove-hook after-save-hook idlwave-revoke-license-to-kill local] 6 (#$ . 110501)])
#@13
(fn FILE)
(defalias 'idlwave-locate-lib-file #[257 "\301\211\3022) \211A\262\242@\211\262\205( \303\304\"\211\262!\203 \305\302\"\210\202 0\207" [idlwave-path-alist nil exit file-regular-p expand-file-name throw] 8 (#$ . 110868)])
#@13
(fn FILE)
(defalias 'idlwave-expand-lib-file-name #[257 "\211\204 \300\207\301!\203
\207\302!\207" [nil file-name-absolute-p idlwave-locate-lib-file] 3 (#$ . 111117)])
#@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 #[0 "\300\211\211\211\211\211\211\211\211\211\211\211\211\211\301\302\303\"\262\304\305\"\262
\306\262\f\307\262 \310\262\n\310\262
8\262\203\311\312 \"\203A \313\262\202D \300\262\203R \314 GO\262\315!\262\316!\203\203\225 \317\320!\262\321\322\300\300\323\324\325Q&\210p\262q\210\304\326\314d{\327\330#\305\"\262q\210\331!\210\202\234 \332PC\262\310\2628\262\203\365 \311\333\"\204\351 \334\335\336\337Q\"\210\317\340!\262 \321\322\300\300\323\nQ&\310=\203\326 \310\202\327 \314\\\262\n\341\262 T\2628\262\202\244 T\2628\262\202\244 T\262
8\262\202. T\262
8\262\202. \317\340!\262 \310U\203#\331!\210\334\342!\207" [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 " ""] 24 (#$ . 111298) nil])
#@345 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.
(fn BEG END &optional N)
(defalias 'idlwave-toggle-comment-region #[770 "\211\203\f \301\302!#\207\212b\210\303 \210\304\305w\210\306\307\310Q!\203' \311\"\202+ \301\")\207" [comment-start comment-region prefix-numeric-value beginning-of-line " \n" nil looking-at "[ ]*\\(" "+\\)" uncomment-region] 8 (#$ . 112960) "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))
#@48 Reset all sintern hashes.
(fn &optional WHAT)
(defalias 'idlwave-reset-sintern #[256 "\303\211\304\211\211:\203' @\262@\262J:\204 \304CL\210A\262\304\262\202 \266\305=\204: \306=\204: A\204k \211\304\211\211\211:\203e @\262@\262A@\262J\307\310\311\312$\241\210A\262\304\262\202? \266\304\211\305=\204} \313=\204} @?\205\253 \211\304\211\211\211:\203\250 @\262@\262A@\262J\307\310\311\312$\240\210A\262\304\262\202\202 \266\304\207" [idlwave-sint-routines idlwave-sint-dirs idlwave-sint-libnames ((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] 14 (#$ . 113842)])
#@33
(fn NAME &optional CLASS SET)
(defalias 'idlwave-sintern-routine-or-method #[769 "\203 \300\"\207\301\"\207" [idlwave-sintern-method idlwave-sintern-routine] 6 (#$ . 114589)])
#@25
(fn STYPE &rest ARGS)
(defalias 'idlwave-sintern #[385 "\300\301\302\303!P!\"\207" [apply intern "idlwave-sintern-" symbol-name] 7 (#$ . 114779)])
#@27
(fn NAME &optional SET)
(defalias 'idlwave-sintern-routine #[513 ";\204 \207\301\227A\"\206% \301\227@\"\206% \211\203$ \302\303$\207\207" [idlwave-sint-routines gethash idlwave-sintern-set routine] 7 (#$ . 114936)])
#@27
(fn NAME &optional SET)
(defalias 'idlwave-sintern-keyword #[513 ";\204 \207\301\227A\"\206% \301\227@\"\206% \211\203$ \302\303$\207\207" [idlwave-sint-keywords gethash idlwave-sintern-set keyword] 7 (#$ . 115172)])
#@27
(fn NAME &optional SET)
(defalias 'idlwave-sintern-method #[513 ";\204 \207\301\227A\"\206% \301\227@\"\206% \211\203$ \302\303$\207\207" [idlwave-sint-methods gethash idlwave-sintern-set method] 7 (#$ . 115408)])
#@27
(fn NAME &optional SET)
(defalias 'idlwave-sintern-class #[513 ";\204 \207\301\227A\"\206% \301\227@\"\206% \211\203$ \302\303$\207\207" [idlwave-sint-classes gethash idlwave-sintern-set class] 7 (#$ . 115641)])
#@26
(fn DIR &optional SET)
(defalias 'idlwave-sintern-dir #[513 "\235\206 B\211@\207" [idlwave-sint-dirs] 4 (#$ . 115872)])
#@27
(fn NAME &optional SET)
(defalias 'idlwave-sintern-libname #[513 "\235\206 B\211@\207" [idlwave-sint-libnames] 4 (#$ . 116006)])
#@29
(fn NAME TYPE TABLES SET)
(defalias 'idlwave-sintern-set #[1028 "\236A\206 \301\211\302=\203 \301\202 \211!\303=\203 A\202\" @\304\227#\210\207" [idlwave-completion-case identity preserve sys puthash] 11 (#$ . 116149)])
#@96 Sintern a set of keywords (file (key . link) (key2 . link2) ...).
(fn KWD-LIST &optional SET)
(defalias 'idlwave-sintern-keyword-list #[513 "\300\301\302\"A\"\210\207" [mapc make-closure #[257 "\211\301@\300\"\240\207" [V0 idlwave-sintern-keyword] 5 "\n\n(fn X)"]] 6 (#$ . 116392)])
#@238 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.
(fn LIST &optional SET DEFAULT-DIR)
(defalias 'idlwave-sintern-rinfo-list #[769 "\300\211\211\211\211\211\211\211\211 \203\277 @\262 A\262\f@\262A@\262\301 8\262\302 8\262\303 8\262\304 \233\262\203] 9\203J \305!\262\306\f\"\262\307\f\"\262\202e \310\f\"\262@A@ \203v \311\f!\202y \3018\3028;\203\211 \312\"\262\211;\203\225 \313\"\262F\262\266\314\315\316
\"\"\262\257\244\262\211B\262\202 \237\207" [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 make-closure #[257 "\301\300\"\207" [V0 idlwave-sintern-keyword-list] 4 "\n\n(fn X)"]] 20 (#$ . 116687)])
#@159 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'.
(fn TAG)
(defalias 'idlwave-new-sintern-type '(macro . #[257 "\300!\211\301P\302\303P!\302\304P!\305\306\307BB\310\311\312\313\314\315\316 EDC\317\320\321\fE\322BB\323BBBBFE\207" [symbol-name "s" intern "idlwave-sint-" "idlwave-sintern-" progn defvar (nil) defun (name &optional set) cond ((not (stringp name)) name) cdr assoc (downcase name) set push (cons (downcase name) name) (name) ((name))] 17 (#$ . 117648)]))
#@59 Reset the sintern variable associated with TAG.
(fn TAG)
(defalias 'idlwave-reset-sintern-type #[257 "\300\301\302!\303Q!\304L\207" [intern "idlwave-sint-" symbol-name "s" nil] 5 (#$ . 118227)])
#@54 Holds the routine-info obtained by scanning buffers.
(defvar idlwave-system-routines nil (#$ . 118430))
#@54 Holds the routine-info obtained by scanning buffers.
(defvar idlwave-buffer-routines nil (#$ . 118540))
#@54 Holds the routine-info obtained by asking the shell.
(defvar idlwave-compiled-routines nil (#$ . 118650))
#@65 Holds the unresolved routine-info obtained by asking the shell.
(defvar idlwave-unresolved-routines nil (#$ . 118762))
#@54 Holds the procedure routine-info from the user scan.
(defvar idlwave-user-catalog-routines nil (#$ . 118887))
#@75 Holds the procedure routine-info from the .idlwave_catalog library files.
(defvar idlwave-library-catalog-routines nil (#$ . 119003))
#@61 Name of library catalog loaded from .idlwave_catalog files.
(defvar idlwave-library-catalog-libname nil (#$ . 119143))
#@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 (#$ . 119269))
#@53 Like `idlwave-path-alist', but with true filenames.
(defvar idlwave-true-path-alist nil (#$ . 119470))
#@60 Holds the combined procedure/function/method routine-info.
(defvar idlwave-routines nil (#$ . 119579))
#@41 Holds the class names known to IDLWAVE.
(defvar idlwave-class-alist nil (#$ . 119688))
#@54 The history of classes selected with the minibuffer.
(defvar idlwave-class-history nil (#$ . 119781))
(defvar idlwave-force-class-query nil)
#@75 The window configuration just before the completion buffer was displayed.
(defvar idlwave-before-completion-wconf nil (#$ . 119928))
#@48 The last cons cell in the system routine info.
(defvar idlwave-last-system-routine-info-cons-cell nil (#$ . 120067))
#@56 The background process currently updating the catalog.
(defvar idlwave-catalog-process nil (#$ . 120190))
#@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 #[0 "\203= \302!\203= \303!\304=\203 \305\306!\210\307\310\311!\210\202= \303!\312=\204= \305\313!\210\314 \210\3151: \316!0\210\202; \210\307 \206E \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 (error) kill-process] 2 (#$ . 120303)])
#@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 (#$ . 120865))
#@68 Rescan the previously selected directories. For batch processing.
(defalias 'idlwave-rescan-catalog-directories #[0 "\300\301!\207" [idlwave-update-routine-info (16)] 2 (#$ . 121049)])
#@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 #[0 "\304!\203< \305!\306=\203/ \307\310!\203( \3111 \312!0\210\202! \210\313\314!\210\202< \313\315!\210\202< \3161; \312!0\210\202< \210 \203K ;\203K \317 !\204O \313\320!\210\n P\321\322\323\324!\322\325\326\327\257\330\331\332\333%\211\334\335\"\210\336\337!\207" [idlwave-catalog-process idlwave-user-catalog-file invocation-directory invocation-name processp process-status run yes-or-no-p "A catalog-updating process is running. Kill it? " (error) kill-process error "Process killed, no new process started" "Quit" (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" nil set-process-sentinel #[514 "\303\304\"\205 \305\211\305\306 \206 \307\310!\207" [idlwave-routines idlwave-system-routines idlwave-catalog-process string-match "finished" nil idlwave-start-load-rinfo-timer idlwave-update-routine-info (4)] 6 "\n\n(fn PRO WHY)"] message "Background job started to update catalog file"] 8 (#$ . 121242) nil])
#@1229 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.
(fn &optional ARG NO-CONCATENATE)
(defalias 'idlwave-update-routine-info #[512 "\306\307!\203\f \307!\204 \306\310!\203 \310!\203 \311!\210\312\267\202) \313 \207\314\315!\207\2063 \2063 \n?\2068 \316\211\316\317\320N\203M \321\317\320\316#\210\202b \317\203V \315\202` \204_ \315\202` \322!\210 \203t \323 \210\203 \324!\210\202 \203| \324!\210\323 \210\306\325!\205\207 \325 \211\205\215 \203\242 \203\237 \326!\327\330#\210\202\242 \331 \210\211\203\252 \204\257 \332\316\333\"\210\211\205\273 \334\335!\210\336\316\315\"\207" [idlwave-load-rinfo-idle-timer idlwave-buffer-case-takes-precedence idlwave-routines idlwave-buffer-routines idlwave-compiled-routines idlwave-unresolved-routines fboundp itimerp timerp cancel-timer #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ((64) 34 (16) 37)) idlwave-rescan-asynchronously 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-system-routines idlwave-query-shell-for-routine-info idlwave-shell-path-query] 11 (#$ . 122514) "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 #[0 "\304\305!\203\f \305!\204 \304\306!\203 \306!\203 \307!\210\310\311\312\"\312\n\205G \n\247\205G \n\313=?\205G ?\205G \3141E \315\n\312\316#\2110\207\210\312\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 (error) run-with-idle-timer idlwave-load-rinfo-next-step] 4])
(defalias 'idlwave-load-system-routine-info #[0 "\302\303\304#\205\n \305 ?\2058 \3061 \307 0\207\210\302\303\304#?\2058 \203( \310\311!\207\310\312!\210\302\313\303\304#?\2058 \310\314!\207" [idlwave-xml-system-rinfo-converted-file idlwave-system-routines load noerror nomessage idlwave-xml-system-routine-info-up-to-date (error) idlwave-convert-xml-system-routine-info 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])
(defalias 'idlwave-xml-system-routine-info-up-to-date #[0 "\301\302\303\304 \"!\302\305\"\306\"\207" [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] 5])
(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 (#$ . 126566))
#@49 Alist of system variables and their help files.
(defvar idlwave-executive-commands-alist nil (#$ . 126741))
(defvar idlwave-help-special-topic-words nil)
#@36
(fn SYNTAX NAME &optional CLASS)
(defalias 'idlwave-shorten-syntax #[770 "\301\302\303\304#\237\305#)\207" [case-fold-search t mapconcat make-closure #[257 "\302\300\"\203 \303\304\305\211$\262\202 \301\203( \302\301\"\203( \303\304\305\211$\262\202 \207" [V0 V1 string-match replace-match "%s" t] 6 "\n\n(fn X)"] " or "] 8 (#$ . 126901)])
#@18
(fn XML-ENTRY)
(defalias 'idlwave-xml-create-class-method-lists #[257 "\211A@\301\236A\302\236AAA\303\304\211\211\211\211\211\211\211\211\211\211 \203\376 @\262<\203\366 @\262A@\262\211\305\267\202\366 \301\236A\302\236A\306\230\203O \211\306\230\204T B\262\266\202\366 \301\236A\302\236A\307 \236A\310\230\311\n\236A\310\230\312 \236A\310\230\203\204 D B\262 \203\220 D\nB\262\n\211\203\234 D B\262 \266\202\366 \301\236A\262\n\313\314P \"\203\275 \315\316\317\303#\210\202\350 \313\320P \"\203\322 \315\321\317\303#\210\202\350 \313\322P \"\203\347 \315\323\317\303#\210\202\350 \304\262\324\n# \244\262 A\262\f\202 \203
\325\326\"\302DE\202
\302DD\262 \n )B\207" [case-fold-search name link t nil #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (SUPERCLASS 57 PROPERTY 89 METHOD 161)) "None" get "Yes" set init string-match "::Init" put init-props matched "::GetProperty" get-props "::SetProperty" set-props idlwave-xml-create-rinfo-list append (inherits)] 23 (#$ . 127262)])
#@44
(fn XML-ENTRY &optional CLASS EXTRA-KWS)
(defalias 'idlwave-xml-create-rinfo-list #[769 "A@\301\236A\302\236AAA\303\304\305\"\306\305\211\211\211\211\211\211\211\211\211\2036 \307\310P\"\2036
\311\225\305O\262 \203 @\262<\203\370 @\262A@\262\312\267\202\370 \301\236A\262\n\307\313 \"\203k \314\315\306\305
$\262\n\316\236A\262\307\317\"\203| \311\202\217 \307\320\"\203\207 \321\202\217 \307\322\"\205\217 \323 \fHBI\266\202\370 \301\236A\262 \302\236A\262\307\324\n\"\203\356 \325\321\n\"\203\277 \326\202\300 \327\262\311\225\305O\262 \305:\203\351 @\262\211 P\nDB\262A\262\202\315 \266\202\370 DB\262 A\262\f\2026 \n\323H\203
\321\305O
B\202a\203 \244\262\330\"\262\311\211\321X\203_ H\203X\331\311=\203@\332\202A\333\334\335H#\257\"B\262\211T\262\202&\210)\207" [case-fold-search name link make-vector 3 nil t string-match "::" 0 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (SYNTAX 84 KEYWORD 159)) "->" replace-match "->" type "^pro" "^fun" 1 "^exec" 2 "^\\[XY\\(Z?\\)\\]" match-string ("X" "Y" "Z") ("X" "Y") idlwave-rinfo-group-keywords append pro fun (system) idlwave-shorten-syntax] 28 (#$ . 128364)])
#@25
(fn KWDS MASTER-LINK)
(defalias 'idlwave-rinfo-group-keywords #[514 "\300\211\211\211\211\211\203N @\262\301A@!\262A\262@\262@\262\302\"\211\262\203< BAB\241\266\202F BDB\262A\262\202 \302\"\211\262\203i @=\203b \207\211\303\"B\207CB\211\262\207" [nil idlwave-split-link-target assoc delq] 12 (#$ . 129642)])
#@16
(fn ALIASES)
(defalias 'idlwave-convert-xml-clean-statement-aliases #[257 "\301\211\301:\203; @\262\302\"\262\2034 \303\304\3058\211\262\"\2034 \305\233\211\306\307\310\211 $\240\266\202 A\262\202 \266\301\207" [idlwave-system-routines nil assoc string-match " +or +" 4 replace-match ", " t] 12 (#$ . 130005)])
#@16
(fn ALIASES)
(defalias 'idlwave-convert-xml-clean-routine-aliases #[257 "\301\211\211\211\211\301:\203B @\262\302A\303\"\211\262\203; \304A\"\262\2041 \211AB\262B\262\305@A\"\241\210A\262\202 \266\211\301:\203f @\262\211A\203_ \211A@@BB\262A\262\202F \266\301:\203\245 @\262\304A\"\211\262\203\236 >\204\215 B\262\306!\262@\240\210BA\262\202j \266\301:\203\276 @\262\307\"\210A\262\202\251 \266\301\207" [idlwave-system-routines nil split-string "/" assoc delete copy-sequence delq] 12 (#$ . 130342)])
#@16
(fn ALIASES)
(defalias 'idlwave-convert-xml-clean-sysvar-aliases #[257 "\301\211\301:\2038 @\262\302A\"\211\262\2031 >\204# B\262\303!\262@\240\210BA\262\202 \266\211\301:\203Q @\262\304\"\210A\262\202< \266\301\207" [idlwave-system-variables-alist nil assoc copy-sequence delq] 8 (#$ . 130923)])
#@18
(fn XML-ENTRY)
(defalias 'idlwave-xml-create-sysvar-alist #[257 "\211A@\301\236A\211\302\303\"\210\304\225\305O\306\236AAA\307\305\211\211\211\203Q @\262<\203J @\262A@\262\310=\203J \301\236A\311\306\236A!ABB\262A\262\202 \312\305\205\\ \313B\306\nDE\")\207" [case-fold-search name string-match "^ *!" 0 nil link t FIELD idlwave-split-link-target delq tags] 16 (#$ . 131259)])
(defvar idlwave-xml-routine-info-file nil)
(defalias 'idlwave-save-routine-info #[0 "\205l \306\307\310\"\311\312\"\216r\211q\210\313\n\314\315\316 \317\260c\210\320\321\"c\210\322c\210\323 p\"\210\324c\210\325c\210\323\fp\"\210\324c\210\326c\210\323
p\"\210\324c\210\327c\210\323 p\"\210\324c\210\330c\210\323 p\"\210\324c)rq\210\331\332\211\332\333%\210*\266\202\207" [idlwave-xml-routine-info-file idlwave-xml-system-rinfo-converted-file idlwave-mode-version idlwave-system-routines idlwave-system-variables-alist idlwave-system-class-info generate-new-buffer " *temp file*" t make-closure #[0 "\301\300!\205 \302\300!\207" [V0 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-executive-commands-alist idlwave-help-special-topic-words] 9])
#@93 Convert XML supplied IDL routine info into internal form.
Cache to disk for quick recovery.
(defalias 'idlwave-convert-xml-system-routine-info #[0 "\306\307\310\311 \"!\307\312\"\313\314\211\211\211\211\211\211\211\211\211\211\211\315!\204( \316\317\"\210\2025 \320!\2045 \316\321\"\210\322\323!\210\324!\262 \322\325!\210\326 \236\262 \n\204R \316\327!\210\nAA\262 \nG\262\330\245\262\n\314\322\331!\210\314\211\314\211\314\n\203N\n@\262 \nA\262 \fT\262
<\203s @\262A@\262\f\332
\"\313U\203\257 \322\333\334\335_\n\"\"\210\336\267\202s \337\f\236\211\262\203\317 \340\f\236AABB\262\202s \341 !\262A<\203\342 \244\202s \fB\202s \342 !\262@ B A\244\202s \340\f\236A\343
\236AB
B\337\f\236\211\262\203s A\235\204s AB\262\202s \337\f\236A\211\262\203D\340\f\236A\344\314O\344\314OBB\262\202s \345 !\nB\202s \346!\210\347!\210\350!\210
\351 \210\322\352!\207" [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 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%%" floor 100.0 #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ROUTINE 182 CLASS 233 STATEMENT 253 SYSVAR 293)) alias_to name idlwave-xml-create-rinfo-list idlwave-xml-create-class-method-lists link 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"] 21 (#$ . 132958) nil])
(defalias 'idlwave-load-rinfo-next-step #[0 "\306\3072\347 \211\310H\204# \311\312!\210\313 \210\311\314!\210\211\310\306I\210\315\307\306\"\210\211\316H\204J \311\317!\210\320\306!\210\321\320\322\306#\210\323\n\324\"\311\325!\210\211\316\306I\210\315\307\306\"\210\211\326H\204\226 ;\203\214 \327 !\203\214 \311\330!\210\3311k \332 !0\210\202q \210\315\307\333\"\210\334\304!\203\210 \f\203\210 \333\335 \210\311\336 \"\210\202\214 \311\337!\210\211\326\306I\210\315\307\306\"\210\211\340H\204\267
\203\255 \311\341!\210\323
\324\"\311\342!\210\211\340\306I\210\315\307\306\"\210\211\343H\204\313 \344\345!\210\211\343\306I\210\315\307\306\"\210\211\346H?\205\346 \311\347!\210\350 \210\311\351!\210\211\346\306I\210\315\307\333\"0\205\376 \352\316!\203\365 \353 \202\376 \354-\333\353#\211.)\207" [idlwave-load-rinfo-steps-done inhibit-quit idlwave-system-routines idlwave-user-catalog-file idlwave-library-routines idlwave-user-catalog-routines t exit 0 message "Loading system routine info in idle time..." idlwave-load-system-routine-info "Loading system routine info in idle time...done" throw 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..." (error) load-file nil 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" sit-for idlwave-load-rinfo-next-step run-with-idle-timer idlwave-init-rinfo-when-idle-after idlwave-load-rinfo-idle-timer] 6])
(defvar idlwave-after-load-rinfo-hook nil)
#@24
(fn &optional FORCE)
(defalias 'idlwave-load-all-rinfo #[256 "\211\204\n \306H\204
\307 \210\211\204 \310H\204$ \311\312!\210\313 \314\"\311\315!\210 \2032 \316 !\211GS\n\233\f;\203\202 \317\f!\203\202 \3201T \211\204L \321H?\205O \322\f!0\210\202U \210\323\305!\203f
\203f \324\325\326\f\"\210\324 \211\204s \327H\204\202 \311\330!\210\313 \314\" \311\331!\210\211\204\214 \332H\204\220 \333\334!\210\335\336!\207" [idlwave-load-rinfo-steps-done idlwave-system-routines idlwave-routines idlwave-last-system-routine-info-cons-cell idlwave-user-catalog-file idlwave-library-routines 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 (error) 2 load-file boundp nil 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] 5 (#$ . 136936)])
(defalias 'idlwave-update-buffer-routine-info #[0 "\302\303\267\202 \304\305!\210\306\307\310 !!\262\202, \302\262\202, \311\312!\203, \304\313!\210\306pC!\262\314\315\"\211\207" [idlwave-scan-all-buffers-for-routine-info idlwave-buffer-routines nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 7 nil 22)) 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] 4])
#@92 Put the different sources for routine information together.
(fn &optional QUIET RUN-HOOK)
(defalias 'idlwave-concatenate-rinfo-lists #[512 "\306 \n $\f\203 \f\241\266\202 \211C\210\307\204, \310\311G G\nG G\fG&\210\211\2053 \312\313!\207" [idlwave-buffer-routines idlwave-compiled-routines idlwave-library-catalog-routines idlwave-user-catalog-routines idlwave-last-system-routine-info-cons-cell idlwave-class-alist append nil message "Routines Found: buffer(%d) compiled(%d) library(%d) user(%d) system(%d)" run-hooks idlwave-update-rinfo-hook idlwave-system-routines] 9 (#$ . 138625)])
#@48 Return the class alist - make it if necessary.
(defalias 'idlwave-class-alist #[0 "\2060 \302 \302:\203+ @\262\3038\211\262\203$ \236\204$ CBA\262\202 \266\262\207" [idlwave-class-alist idlwave-routines nil 2] 5 (#$ . 139231)])
(defalias 'idlwave-save-buffer-update #[0 "\300\301!\207" [idlwave-update-current-buffer-info save-buffer] 2])
(defalias 'idlwave-kill-buffer-update #[0 "\300\301!\207" [idlwave-update-current-buffer-info kill-buffer] 2])
(defalias 'idlwave-new-buffer-update #[0 "\300\301!\207" [idlwave-update-current-buffer-info find-file] 2])
#@89 Update `idlwave-routines' for current buffer.
Can run from `after-save-hook'.
(fn WHY)
(defalias 'idlwave-update-current-buffer-info #[257 "\303\304!\205@ \305=\204 \211>\205@ \205@ \n\205@ \3061> \307\310\311 \312=?\2053 \313\314pC!\315\"\211\262\"\210\316\317!\210\211\2620\207\210\307\207" [idlwave-auto-routine-info-updates idlwave-scan-all-buffers-for-routine-info idlwave-routines derived-mode-p idlwave-mode t (error) 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] 7 (#$ . 139812)])
#@85 Cut the part from FILE out of `idlwave-buffer-routines' and add NEW.
(fn FILE NEW)
(defalias 'idlwave-replace-buffer-routine-info #[514 "\301\203) \302\303@8!=\203 \301\240\210\304\262\202\" \211\203\" \301\262A\262\202 \305\306\301\"\"\211\207" [idlwave-buffer-routines nil idlwave-routine-source-file 3 t append delq] 9 (#$ . 140446)])
#@92 Call `idlwave-get-buffer-routine-info' on `idlwave-mode' buffers in BUFFERS.
(fn BUFFERS)
(defalias 'idlwave-get-routine-info-from-buffers #[257 "\301\211\211\212\211A\262\242\211\262\2033 q\210\302\303!\203 \203 \3041' \305 0\202) \210\301\262\211B\262\202 )\306\307\"\207" [buffer-file-name nil derived-mode-p idlwave-mode (error) idlwave-get-buffer-routine-info apply nconc] 7 (#$ . 140805)])
#@73 Scan the current buffer for routine info. Return (PRO-LIST FUNC-LIST).
(defalias 'idlwave-get-buffer-routine-info #[0 "\301\302\211\211\212\214~\210eb\210\303\304\302\301#\203+ \305\306\224\307 \210`\"\262\310!\262\211B\262\202\f *)\207" [case-fold-search t nil re-search-forward "^[ ]*\\(pro\\|function\\)[ ]" buffer-substring-no-properties 0 idlwave-end-of-statement idlwave-parse-definition] 7 (#$ . 141220)])
#@41 Parse a module definition.
(fn STRING)
(defalias 'idlwave-parse-definition #[257 "\302\303\211\211\211\211\211\304\305 \"\203 \306\307\302\211 $\262\202\n \304\310 \"\2032 \306\311\302\303 $\262\202 \304\312 \"\203F \306\313\302\303 $\262\2022 \304\314 \"\203m \315\225\262\316\317 \"\227\262\320\224\203f \316\320 \"\262\316\321 \"\262\304\322 #\203\230 \315\225\262\320\224\203\214 \316\317 \"B\262\202m \316\317 \"B\262\202m \237\262\323\324\"\262\325\232\203\255 \326\202\256 \327\330\331!\204\274 \332\333 D\202\304 \334\335\333 ! \336F\337\230\203\317 \340\202\320 \307\203\330 \341\202\331 \307\342\n\205\376 \337\230\203\352 \343\202\353 \344\345\346
\344# \337\230\203\374 \347\202\375 \307QR\205 \303\350\351 \"B\257)\207" [case-fold-search idlwave-scanning-lib-dir 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 #[514 "\227\227\231\207" [] 4 "\n\n(fn A B)"] "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] 20 (#$ . 141649)])
#@61 Return the syslib directory, or a dummy that never matches.
(defalias 'idlwave-sys-dir #[0 "\203\f \301\230\204\f \207\302\303!\206 \304\207" [idlwave-system-directory "" getenv "IDL_DIR" "@@@@@@@@"] 2 (#$ . 143013)])
#@409 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.
(fn &optional ARG)
(defalias 'idlwave-create-user-catalog-file #[256 ";\203 \305!\203 \3061 \307!0\210\202 \210;\2034 G\310V\2034 \311\312!!\2034 \313!\314\230\2038 \315\316!\210\211\203J \203J @:\203J \317 !\207\n\203d \320 \203\\ \321\322\323\n!\"\202b \321\324\323\n!\"!\207\325\326!\210\327\330!\210\331\f\332\333#\207" [idlwave-user-catalog-file idlwave-path-alist idlwave-library-path idlwave-true-path-alist idlwave-shell-path-query file-regular-p (error) load-file 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 #[257 "\301\302!\"\211\203 AB\207C\207" [idlwave-true-path-alist assoc file-truename] 4 "\n\n(fn X)"] 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] 6 (#$ . 143242) "P"])
#@22
(fn &optional ARG)
(defalias 'idlwave-user-catalog-command-hook #[256 "\211\203 \301!\207\302\303!\210\304\305\306\"\210\307!\207" [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] 4 (#$ . 144648)])
(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")
#@87 Create the widget to select IDL search path directories for scanning.
(fn DIRS-LIST)
(defalias 'idlwave-display-user-catalog-widget #[257 "\304\305!\210\304\306!\210\211\204 \307\310!\210\311\312\313!!\210\314\312\313!!\210\315 \210\316\302!\210\317\320 \"!\210\321\322\323\324\325$\210\317\326!\210\321\322\323\327\330$\210\317\326!\210\321\322\323\331\332$\210\317\326!\210\321\322\323\333\334$\210\317\326!\210\321\322\323\335\336$\210\317\337!\210\317\340!\210\341\321\342\343\344\345\346\347\"\"\350\351\352\353\346\354 \"& \355\n\356#\210\317\357!\210\360 !\210\361 \210eb\210\362 \207" [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" #[128 "\301\302\"\211\211\203 \211@\303A>\204 \304\305\"\210A\266\202\202 \210\306!\207" [idlwave-widget widget-get :path-dirs lib idlwave-path-alist-add-flag user idlwave-display-user-catalog-widget] 7 "\n\n(fn &rest IGNORE)"] "Select All Non-Lib" #[128 "\301\302\"\211\211\203 \211@\303\304\"\210A\266\202\202 \210\305!\207" [idlwave-widget widget-get :path-dirs idlwave-path-alist-remove-flag user idlwave-display-user-catalog-widget] 7 "\n\n(fn &rest IGNORE)"] "Deselect All" #[128 "\300p!\207" [kill-buffer] 3 "\n\n(fn &rest IGNORE)"] "Quit" "\n\n" "Select Directories: \n" apply checklist :value delq nil mapcar #[257 "\300A>\205 \211@\207" [user] 3 "\n\n(fn X)"] :greedy t :tag "List of directories" #[257 "\300\301A>\203 \302@P\202 @D\207" [item lib "[LIB] "] 4 "\n\n(fn X)"] widget-put :path-dirs "\n" use-local-map widget-setup delete-other-windows] 13 (#$ . 145736) nil])
#@21
(fn &rest IGNORE)
(defalias 'idlwave-delete-user-catalog-file #[128 "\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"] 5 (#$ . 147671)])
#@21
(fn &rest IGNORE)
(defalias 'idlwave-widget-scan-user-lib-files #[128 "\301!\302\303\"\211\304\211A\262\242\211\262\203; \305A>\203$ \306@P\202& \211@\235\2033 \307\310\"\210\202\n \311\310\"\210\202\n \312!\207" [idlwave-widget 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] 9 (#$ . 147922)])
#@19
(fn PATH-ALIST)
(defalias 'idlwave-scan-user-lib-files #[257 "\306\307\310\211\310\211\211\211\3103\203 \311 \210r\312\313!q\210\314 \210\315!\262\211A\262\242\211\262\203\204 \316A>\203& @\262\317!\203& \320\321\322#\262\211A\262\242\211\262\203& \323!\203L \324!\204l \325\326\"\210\202L \325\327\"\210\330 \210\331\332\"\210\333\334pC! \"\202L )\325\335!\210\336\313!\210\336\312\337!!\210\340\341\306\"r\211q\210\342\343\"\216\344c\210\345\346\347 \"c\210\350c\210p 4\351\352 \"\210)\345\353\3545!\"c\210\355\310\2115#\210*\210+\266\325\356!\210\325\357 G5#\210\360\361!\210\362\306!\207" [idlwave-scanning-lib idlwave-scanning-lib-dir idlwave-completion-case idlwave-user-catalog-routines idlwave-path-alist idlwave-true-path-alist 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*" generate-new-buffer " *temp*" make-closure #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] ";; IDLWAVE user catalog file\n" format ";; Created %s\n\n" current-time-string "\n(setq idlwave-user-catalog-routines\n '(" mapc #[257 "\300c\210\301!\210db\207" ["\n " prin1] 3 "\n\n(fn X)"] "))\n\n;;; %s ends here\n" file-name-nondirectory write-region "Creating user catalog file...done" "Info for %d routines saved in %s" sit-for 2 idlwave-update-routine-info idlwave-auto-write-paths standard-output idlwave-user-catalog-file] 11 (#$ . 148334)])
(defalias 'idlwave-read-paths #[0 ";\205 \301!\205 \3021 \303\304\211\211$0\207\210\305\207" [idlwave-path-file file-regular-p (error) load t nil] 5])
(defalias 'idlwave-write-paths #[0 "\205; \205; \304\305\306\"r\211q\210\307\310\"\216\311c\210\312\313\314 \"c\210\312\315 \"c\210\316c\210p\317\320\"\210)\321c\210\322\323\211 #*\262\207" [idlwave-path-alist idlwave-system-directory standard-output idlwave-path-file generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] ";; 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 #[257 "\300c\210\301!\210db\207" ["\n " prin1] 3 "\n\n(fn X)"] "))\n" write-region nil] 5 nil nil])
#@35
(fn PATH &optional DEFAULT-DIR)
(defalias 'idlwave-expand-path #[513 "\300\301!\210\302\211\211\211A\262\242\211\262\203L \303\304O\305\230\211\262\203% \304\302O\262\211\2035 \306!\2045 \307\"\262\211\203D \310\311!\"\262\202 B\262\202 \300\312!\210\237\207" [message "Expanding path..." nil 0 1 "+" file-name-absolute-p expand-file-name append idlwave-recursive-directory-list "Expanding path...done"] 8 (#$ . 150881)])
#@12
(fn DIR)
(defalias 'idlwave-recursive-directory-list #[257 "\211C\300\211\211\211A\262\242\211\262\203C \301!\203 \302\303\304#\237\262\211A\262\242\211\262\203; \301!\203 \305!B\262\202 B\262\202 \207" [nil file-directory-p directory-files t "[^.]" file-name-as-directory] 9 (#$ . 151331)])
#@425 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.
(fn &optional MESSAGE-BASE NO-LOAD)
(defalias 'idlwave-scan-library-catalogs #[512 "\205\250 \203 \305 !\202 \306\307\n\"\310\311\211\211\211\203\" \312\313 \"\210\211A\262\242\211\262\203\225 \3142\221 \315\316\317\"\211\262!\205\220 \204~ \311\3201T \321\322\211\211$0\210\202Z \210\323\314\322\"\210\203o \f\230\204o \312\324 \f#\210\f\262 \203~ \325\326 \327#\"\262\n\205\220 \330\n\"\211\262\205\220 \331\332\"0\210\202\" \204\234 \211\205\246 \312\333 \"\266\206\207" [idlwave-use-library-catalogs idlwave-library-path idlwave-path-alist idlwave-library-catalog-routines idlwave-library-catalog-libname idlwave-expand-path mapcar car "" nil message "%s" continue file-readable-p expand-file-name ".idlwave_catalog" (error) load t throw "%s%s" append idlwave-sintern-rinfo-list sys assoc idlwave-path-alist-add-flag lib "%sdone"] 13 (#$ . 151653)])
#@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" (#$ . 152935))
#@61 Remember if the routine info procedure is already compiled.
(defvar idlwave-idlwave_routine_info-compiled nil (#$ . 156702))
#@23
(fn &optional WAIT)
(defalias 'idlwave-shell-compile-helper-routines #[256 "\203\f \304\305\306!!\2046 r\307\305\310!!q\210\311 \210 c\210\312\313!\210)\314\315\n\316Q\317\320$\210\314\321\322\305\306!\"\317\320#\210\323\314\321\324 \211#\317\320#\207" [idlwave-idlwave_routine_info-compiled idlwave-routine-info\.pro idlwave-shell-temp-pro-file 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'"] 6 (#$ . 156833)])
#@118 Query the shell for routine_info of compiled modules and update the lists.
(fn &optional QUIET RUN-HOOKS WAIT FILE)
(defalias 'idlwave-shell-update-routine-info #[1024 "\300!\210\301\302\303\203 \304\305Q\202 \306\"\307\310\311EE\312$\207" [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] 11 (#$ . 157683)])
(defvar idlwave-completion-help-info nil)
(defvar idlwave-completion-help-links nil)
(defvar idlwave-current-obj_new-class nil)
#@1930 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 \[universal-argument] forces completion of
function names in places where the default would be a keyword.
Two prefix argument, \[universal-argument] \[universal-argument], 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.
(fn &optional ARG MODULE CLASS)
(defalias 'idlwave-complete #[768 "\306 \210\203 \250\203 \307\232\203 9\203 \310#\202! \311 \3128\313\232\314\232\2052 \315\316!C\203L \317\320\"\203L \321\211\224O\262\321\225\322O\262\204d \n\242\323=\203d \324\325!\203d \n\326 \202\376\327 \203t \211\330=\204t \331 \202\376\332\333!\206\376\211\334\267\202Q\335\336!\202\376\337\340 \202\376\3418\342\343\" \344!?\205\237 \345
! @\346
\203\252 \347\202\253 \350P\343 A\351\322A
\322@\257\352\353
\203\304 \354\202\305 \351\306 \355\356\357
\203\341 \356\360
\361=\203\334 \362\202\335
\"\202\342 \350#\363\364&+\266\202\202\376\3418\342\365\" \344!?\205\345
! @\366
\203\f\347\202
\350P\365 A\351\322A
\322@\257\352\367
\203&\354\202'\351\306 \355\356\357
\203C\356\360
\361=\203>\362\202?
\"\202D\350#\363\364&+\266\202\202\376\211\370>\203c\371\232\203c\372\341!\202\376\211\373\267\202\371\3418\211@\211 B\343 A\342\343\"\211 \345
! @\356\374\203\211\347\202\212\350\"\375\343\306 $\211\205\234\3418@\376=\377\201D \"\204\272\361=\204\272\335\201E \201F \"\"\210\201G \343@&\262\211\204\335\335\201H \201F \"\"\210\201I A
@\257\352\201I \211\322\356\201J \201F \f\"\201K \235\204\201L \235\203\201M \202\350# \201N &,\266\207\202\376\3418\211@\211 B\365 A\342\365\"\211 \345
! @\356\201O \203H\347\202I\350\"\375\365\306 $\211\205[\3418@\376=\377\201D \"\322\204z\361=\204z\335\201P \201F \n\"\"\210\201G \365@&\262\204\242\226\201Q \230\203\242C\201R P\202\252\201F \"\262\204\267\335\201S \"\210\201I A
\322@\257\352\201I \211\322\356\201T \201U \n\235\204\344\201V \n\235\203\352\201M \202\353\350#\n\201N &,\266\210\202\376\335\201W !*\207" [idlwave-force-class-query completion-regexp-list last-command this-command idlwave-completion-help-info idlwave--class-selector 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 class idlwave-complete-filename run-hook-with-args-until-success idlwave-complete-functions #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 128 class 134 procedure 141 function 239)) error "Nothing to complete here" (class) idlwave-complete-class 3 idlwave-determine-class pro idlwave-explicit-class-listed idlwave-all-class-inherits "procedure" "-method" "" routine idlwave-complete-in-buffer procedure method idlwave-selector format "Select a %s name%s" " (class is %s)" t "unknown" idlwave-attach-method-classes idlwave-add-file-link-selector fun "function" function (procedure-keyword function-keyword) (4) idlwave-complete #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (procedure-keyword 361 function-keyword 550)) "procedure%s-keyword" idlwave-best-rinfo-assq system idlwave-entry-keywords idlwave--super-classes idlwave--type-selector idlwave--method-selector idlwave-current-obj_new-class do-link "Nothing known about procedure %s" idlwave-make-full-name 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%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)"] 23 (#$ . 158279) "P"])
(byte-code "\300\301\302\303#\210\304\211\203( \211@\301N\203! \302N\204! \305\302\301N#\210A\266\202\202 \210\306\301\302\307#\207" [defvaralias idlwave-complete-special idlwave-complete-functions nil (saved-value saved-variable-comment) put make-obsolete-variable "28.1"] 7)
#@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-functions nil (#$ . 164155))
#@29
(fn FUNCTIONS &rest ARGS)
(defalias 'idlwave-call-special #[385 "\300\211\3012' \211A\262\242\211\262\203% \302\"\211\262\203 \303\301\"\210\202 \3000\207" [nil exit apply throw] 8 (#$ . 164622)])
(make-obsolete 'idlwave-call-special 'run-hook-with-args-until-success "28.1")
#@36
(fn WHAT &optional MODULE CLASS)
(defalias 'idlwave-make-force-complete-where-list #[769 "\303\304\"\305!\306=\203 \307\310\311\312\313$!\211\262\202I \250\203/ \307S8@!\211\262\202I \203F 9\203F \314\315!\"\203F \202I \316\317!\320\312\211\206Q \313\312F\321\267\202 \211\322\312\257\207\312\211\323\206q \324\325\326 \327#\330!\262\211\331\312\211\211F\312\257+\207\211\332\312\257\207\312\211\333\206\233 \324\334\326 \327#\330!\262\211\335\312\211\211F\312\257+\207\211\322\312\257\207\336\323\"\211\337!\323\206\316 \324\340\341\"\326 \327#\342!\262\211\331\312\312F\312\257+\207\211\332\312\257\207\336\333\"\211\337!\333\206\324\340\343\"\326 \327#\342!\262\211\335\312\312F\312\257+\207\211\344\312\257\207\316\345!\207" [idlwave--class-selector idlwave--super-classes idlwave--type-selector (("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) #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (procedure 89 procedure-keyword 97 function 131 function-keyword 139 procedure-method 173 procedure-method-keyword 181 function-method 225 function-method-keyword 233 class 277)) procedure pro idlwave-completing-read "Procedure: " idlwave-routines idlwave-selector idlwave-sintern-routine procedure-keyword function fun "Function: " function-keyword idlwave-determine-class idlwave-all-class-inherits format "Procedure in %s class: " idlwave-sintern-method "Function in %s class: " class "Invalid value for WHAT"] 19 (#$ . 164916)])
#@19
(fn &rest ARGS)
(defalias 'idlwave-completing-read #[128 "\300\301!\302\303\"\216\304\301\305\"\210\306\307\")\207" [default-value completion-ignore-case make-closure #[0 "\301\302\300\"\207" [V0 set-default completion-ignore-case] 3] set-default t apply completing-read] 5 (#$ . 166768)])
#@47 Use the comint stuff to complete a file name.
(defalias 'idlwave-complete-filename #[0 "\304\305!\210\306\307\310\300!\203 ;\203 \311!\203 \202 \312 +\207" [idlwave-shell-default-directory default-directory comint-completion-addsuffix comint-file-name-chars require comint "~/A-Za-z0-9+@:_.$#%={}\\-" nil boundp file-directory-p comint-dynamic-complete-filename] 4 (#$ . 167068)])
#@19
(fn CLASS NAME)
(defalias 'idlwave-make-full-name #[514 "\203 \300\301\"\202\f \302P\207" [format "%s::" ""] 5 (#$ . 167466)])
#@82 Like `idlwave-rinfo-assq', but sintern strings first.
(fn NAME TYPE CLASS LIST)
(defalias 'idlwave-rinfo-assoc #[1028 "\300\301\"\302!$\207" [idlwave-rinfo-assq idlwave-sintern-routine-or-method idlwave-sintern-class] 9 (#$ . 167605)])
#@29
(fn NAME TYPE CLASS LIST)
(defalias 'idlwave-rinfo-assq #[1028 "\30025 \301\236\211\262\2052 \302=\204 \211A@=\203) \3038=\203) \304\300\"\210\211>A\262\202 \2620\207" [exit nil t 2 throw] 8 (#$ . 167853)])
#@29
(fn NAME TYPE CLASS LIST)
(defalias 'idlwave-rinfo-assq-any-class #[1028 "\300!B\301\203$ \302\211A\262\242$\211\262\203 \301\262\202 \207" [idlwave-all-class-inherits nil idlwave-rinfo-assq] 11 (#$ . 168081)])
#@276 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.
(fn NAME TYPE CLASS LIST &optional WITH-FILE KEEP-SYSTEM)
(defalias 'idlwave-best-rinfo-assq #[1540 "\300\301$\"\302G\303V\203J \304\305\"\262\204= \306@8@\307=\203= \310A!\211\262\203= \211\303=\204= A\262\203J \311\302\312\313\"\"\262@\207" [idlwave-routine-twins idlwave-rinfo-assq-any-class nil 1 sort idlwave-routine-entry-compare-twins 3 system idlwave-any-syslib delq mapcar #[257 "\3008A@\205 \211\207" [3] 3 "\n\n(fn X)"]] 13 (#$ . 168316)])
#@119 Like `idlwave-best-rinfo-assq', but sintern strings first.
(fn NAME TYPE CLASS LIST &optional WITH-FILE KEEP-SYSTEM)
(defalias 'idlwave-best-rinfo-assoc #[1540 "\300\301\"\302!&\207" [idlwave-best-rinfo-assq idlwave-sintern-routine-or-method idlwave-sintern-class] 13 (#$ . 169015)])
#@99 Does the entry list ENTRIES contain a syslib entry?
If yes, return the index (>=1).
(fn ENTRIES)
(defalias 'idlwave-any-syslib #[257 "\300\301\30221 \203/ \211T\262\303\304@8!\262\203( \305!\203( \306\302\"\210\202 A\262\202 \3000\207" [nil 0 exit idlwave-routine-source-file 3 idlwave-syslib-p throw] 6 (#$ . 169321)])
#@66 Return a list of all associations of Key in LIST.
(fn KEY LIST)
(defalias 'idlwave-all-assq #[514 "\300\211\236\211\262\203 \211B\262\211>A\262\202 \237\207" [nil] 6 (#$ . 169659)])
#@178 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.
(fn METHOD &optional TYPE)
(defalias 'idlwave-all-method-classes #[513 "\204\n \300\301\302 \"\207\303C\304\305\306#\307\310 \"\"\210\311\242!\207" [mapcar car idlwave-class-alist nil mapc make-closure #[257 "\3028\205 \300\203 \300A@=\205 \301\3028\301\242B\240\207" [V0 V1 2] 4 "\n\n(fn X)"] idlwave-all-assq idlwave-routines idlwave-uniquify] 8 (#$ . 169859)])
#@207 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.
(fn METHOD KEYWORD &optional TYPE)
(defalias 'idlwave-all-method-keyword-classes #[770 "?\206 ??\205\" \300C\301\302\303$\304\305 \"\"\210\306\242!\262\207" [nil mapc make-closure #[257 "\3038\205# \301\203 \301A@=\205# \304\300\305!\"\205# \302\3038\302\242B\240\207" [V0 V1 V2 2 assoc idlwave-entry-keywords] 5 "\n\n(fn X)"] idlwave-all-assq idlwave-routines idlwave-uniquify] 10 (#$ . 170391)])
#@77 Return list of all elements in LIST which are also in CLUB.
(fn LIST CLUB)
(defalias 'idlwave-members-only #[514 "\300\203 @\235\203 @B\262A\262\202 \211\237\207" [nil] 5 (#$ . 170981)])
#@76 Return list of all elements in LIST which are not in CLUB.
(fn LIST CLUB)
(defalias 'idlwave-nonmembers-only #[514 "\300\203 @\235\204 @B\262A\262\202 \211\237\207" [nil] 5 (#$ . 171186)])
#@143 Return whether or not the class is listed explicitly, ala a->b::c.
INFO is as returned by `idlwave-what-function' or `-procedure'.
(fn INFO)
(defalias 'idlwave-explicit-class-listed #[257 "\3008\211\205 \212\211b\210\301\302!)\207" [3 looking-at "->[a-zA-Z][a-zA-Z0-9$_]*::"] 4 (#$ . 171394)])
(byte-code "\300\301\302\303#\210\304\211\203( \211@\301N\203! \302N\204! \305\302\301N#\210A\266\202\202 \210\306\301\302\307#\207" [defvaralias idlwave-determine-class-special idlwave-determine-class-functions nil (saved-value saved-variable-comment) put make-obsolete-variable "28.1"] 7)
#@84 Special hook to determine a class.
The functions should accept one argument, APOS.
(defvar idlwave-determine-class-functions nil (#$ . 171994))
#@18
(fn INFO TYPE)
(defalias 'idlwave-determine-class #[514 "\3058\3068\307@;\203 @\226\202 @\"@\203 \310\202! \311\236\203, A\2026 \211\2035 \211A\2026 \312\205A \305\\{\313\230\211\205S \212b\210\314\315!\210\312\316\317!*\n\320\211\211\n\321\267\202[\320\207\203\201 \322\n\323\"\203\201 \203\201 \204\201 \322\n\323\"\262 \324 !\262 \n\312=\203\227 \203\227 \305\325 8\206\225 \n\262 \n\312=\203\265 \204\265 \326\327 \"\262\203\265 \324!\262 \262\n\312=\203\204\305 \203\330\331\332@\"\"\262\324G\333U\203\346 \204\346 \334\335@\"\202G\336U\203\367 \204\367 @@\202 \262\337\340\341@;\203\340\342@#\202\343\"\320\211\211\344&!\262 \n\203X\n\312=\204X\203N\203N\3451I\346\n\211\305\\\323\347\f\350BBBB#0\210\202N\210\202N\210\fAA\211\f\240\266\n\207\n\207" [idlwave-query-class case-fold-search idlwave-force-class-query idlwave-store-inquired-class idlwave-class-arrow-face 2 3 assoc keyword-default method-default t "->" forward-word-strictly -1 looking-at "self\\>" nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 94 t 96)) get-text-property idlwave-class idlwave-sintern-class idlwave-current-routine run-hook-with-args-until-success idlwave-determine-class-functions 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 (error) add-text-properties face (rear-nonsticky t)] 21 (#$ . 172144)])
#@10
(fn A)
(defalias 'idlwave-selector #[257 "\211A@=\205! \3038\203 \304=\206! \3038 =\206! \3038\n>\207" [idlwave--type-selector idlwave--class-selector idlwave--super-classes 2 t] 3 (#$ . 173709)])
#@10
(fn A)
(defalias 'idlwave-add-file-link-selector #[257 "\301!\302\203 \303!\211\262\203 @BB\207" [idlwave-completion-help-links idlwave-selector nil idlwave-entry-has-help] 5 (#$ . 173920)])
#@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 #[0 "\301 \210\212\302\303!\210`)\304!\211@A@\3058\3068\206 \307\3108\206# \307\311!\211@A@\3058\3068\2066 \307\312 \313\f`{\314\211\211\211\211
W\203N \314\262\315\316\"\203\\ \317\262\202 \315\320 \307V\203l `{\202n \"\203\204 \321\262 \262\262\262\202 \315\322\"\204 \315\323\"\203\232 \317\262\202 \315\324\"\203\250 \317\262\202 \203\331
V\203\331 \f\325U\203\331 \326>\203\331 \327\262\262
\262\262\262\202 \n\203\373 \330=\203\373 \331\262\n\262\262 \262\262\202 \332\262\212\333\334\313#\203 \335\307\224!\262\310\225\203\336\337\310!!\202 \313\262)\n FFF\n\257)\207" [case-fold-search 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] 26 (#$ . 174131)])
#@24
(fn &optional CLASS)
(defalias 'idlwave-this-word #[256 "\211\206 \300\262\212\211\301x\210`\301w\210`{)\207" ["a-zA-Z0-9$_." nil] 4 (#$ . 176219)])
#@24
(fn &optional BOUND)
(defalias 'idlwave-what-function #[256 "\3012\231 \302\211\303\302\211\211\304 p\305\306#\216\307!\210\214\212\310 \206 \303]d}\210\31111 \312\313!\210\3140\2025 \210\202\221 \203\221 `\262T\262g\315U\203\212 \316\317\n\314#\203\212 \320\321!\262\321\224b\262\262\316\322\n\314#\203t \323\303\224!\262\320\321!\206r \314\262\324\301\325\"\326! \257\"\210b\210\202$ \324\301\302\"+\266\2100\207" [idlwave-find-symbol-syntax-table exit nil 0 syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table 1 (error) up-list -1 t 40 re-search-backward "\\(::\\|\\<\\)\\([a-zA-Z][a-zA-Z0-9$_]*\\)[ ]*\\=" match-string 2 "->[ ]*\\(\\([a-zA-Z][a-zA-Z0-9$_]*\\)::\\)?\\=" copy-marker throw idlwave-sintern-routine-or-method idlwave-sintern-class] 16 (#$ . 176379)])
#@24
(fn &optional BOUND)
(defalias 'idlwave-what-procedure #[256 "`\300\211\211\211\211\212\301\302!\210`{\262\303\304\"\203' \305\306\"\262`\306\224\\\262\202i \307 \203i `{\211\262\203i \303\310\"\203i \311\224\205F \305\311\"\262\311\224\203T `\311\224\\\202U \262\312`\306\224\\!\262\305\313\"\206g \314\262)\315\"\316!F\207" [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] 11 (#$ . 177238)])
(defalias 'idlwave-skip-object #[0 "`\3012\200 \212\302\303w\210\304\303w\210\305!\203 \306\225b\210\202& g\307=\204& \310\301\303\"\210\3112h g\312=\203E \313u\210\305!\204> \310\301\303\"\210\306\225b\210\202* g\314>\203` \3151W \316\313!0\210\202* \210\310\301\303\"\210\202* \310\311\317\"\210\202* \210\305\320!\203z \310\301\306\224\211\262\"\202~ \310\301\303\")0\205\205 \211b\207" [idlwave-identifier exit " " nil "*" looking-at 0 40 throw endwhile 46 1 (40 91) (error) forward-list t "[ ]*->"] 5])
#@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 #[0 "\3002K \212\301\302x\210h\303=\203 \304u\210\305\302x\210h\306>\203$ \307\300\302\"\210\202 h\310=\203C \311\312!\210\313\314!\203; \315\225b\210\202 \307\300\302\"\210\202 \307\300h\"\210\202 \207" [exit "a-zA-Z0-9_$" nil 47 -1 " " (59 36) throw 10 beginning-of-line 0 looking-at "\\([^\n]*\\)\\$[ ]*\\(;[^\n]*\\)?\n" 1] 3 (#$ . 178480)])
#@53 A function to evaluate after successful completion.
(defvar idlwave--complete-after-success-function 'ignore (#$ . 179192))
#@76 A function to evaluate after completion selection in *Completions* buffer.
(defvar idlwave--complete-after-success-force-function 'ignore (#$ . 179322))
#@60 A mark pointing to the beginning of the completion string.
(defconst idlwave-completion-mark (make-marker) (#$ . 179481))
#@478 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'. SPECIAL-SELECTOR is
used only once, for `all-completions', and can be used to, e.g.,
accumulate information on matching completions.
(fn TYPE STYPE LIST SELECTOR PROMPT ISA &optional PREPARE-DISPLAY-FUNCTION SPECIAL-SELECTOR)
(defalias 'idlwave-complete-in-buffer #[2054 "\306\307C`\307C\307\211\211\211\211\211\204 \310
\311P!\210\212\312\307x\210h\313=\240\210`\240\210\314\315 \n$\314\316 #)\242{\262\227\262\317\"\262\320#\262;\205b \227\262\307\204u \310
\321P\"\202D\232\204\276 \306=\204\276 \242|\210\230\203\240 \322\230\203\230 \f\203\240
\204\240 \211\202\241 c\210\320#\306=\203\272 \323\242 \242#\210\306\202D\306=\204\342 \324\325
\206\321 #!\211\262G\326U\203\371 \232\203\371 \323\242 \242#\210\327\330#\210\307\202D\327\331!\210 \204\332\333\"\210>\334\335\"\262\f\203 \f!\262\230\2038\322\230\203.\f\2038
\2048\336\337\"\262\340
\242$\266\306)\207" [completion-ignore-case idlwave--complete-after-success-function idlwave--complete-after-success-force-function idlwave-completion-help-links idlwave-complete-empty-string-as-lower-case idlwave-completion-force-default-case t nil error ": No completions available" "a-zA-Z0-9_$" 47 make-closure #[0 "\303\300\302\242\301\242#\207" [V0 V1 V2 idlwave-after-successful-completion] 4] #[0 "\302\300\301\242\303#\207" [V0 V1 idlwave-after-successful-completion force] 4] idlwave-sintern try-completion ": no completion for \"%s\"" "" idlwave-after-successful-completion idlwave-uniquify all-completions 1 message "%s is already the complete %s" "Making completion list..." mapc #[257 "\301\302\303@#\211\205 @BB\211\207" [idlwave-completion-help-links get-text-property 0 link] 5 "\n\n(fn X)"] sort #[514 "\227\227\231\207" #1=[] 4 "\n\n(fn A B)"] mapcar #[257 "\211<\203\f \211@\227\240\210\207\211\227\207" #1# 3 "\n\n(fn X)"] idlwave-display-completion-list] 24 (#$ . 179610)])
#@28 Complete a class at point.
(defalias 'idlwave-complete-class #[0 "\301 \210\302\212\303\304`\305Z\302#\205 eb\205 \306\307\310\302#*\203# \311\312!c\207\313\314\211\315 \310\316\317\320&\207" [case-fold-search idlwave-routines t re-search-backward "\\<\\(pro\\|function\\)[ ]+\\=" 15 re-search-forward "^[ ]*\\(pro\\|function\\)[ ]+\\([a-zA-Z0-9_]+::\\)" nil match-string 2 idlwave-complete-in-buffer class idlwave-class-alist "Select a class" "class" #[257 "\300\301\"\207" [mapcar #[257 "\301!\302\236A@\211\203 BB\207" [idlwave-completion-help-links idlwave-class-info link] 5 "\n\n(fn X)"]] 4 "\n\n(fn LIST)"]] 8 (#$ . 181840) nil])
#@31
(fn LIST TYPE SHOW-CLASSES)
(defalias 'idlwave-attach-classes #[771 "\211\203 \203 ;\203 \204 \207\211\302Y\302U?\303=?\205( \205( B\304!\305\306\307\310\n\"\"\311C\311C\311C\311C\307\312\313
\f\f\f\f\f\f\f\f\f&
\"\207" [idlwave--class-selector idlwave--super-classes 0 class-tag abs apply max mapcar length nil make-closure #[257 "\300\312=\203 \306\313\"\"C\240\210\202< \306\300\314=\203# \315#$#\202( \316$\"\240\210\303\203< \306\317\320\321\322\323\303\"\306\242\"\"\240\210\307\306\242G\240\210\311\324\325\305GZ\326\"P\240\210\302\203w \307\242\304X\203j \310\311\242\327\330\331\306\242\332#\333R\240\210\202{ \310\334\335\311\242\307\242#\240\210\202{ \310\320\240\210\301\203\222 \336!\262\337\340G\341\330\331\306\242\324#%\210\310\242\203\234 \211\310\242D\207\207" [V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 class-tag idlwave-class-or-superclass-with-tag kwd idlwave-all-method-keyword-classes idlwave-all-method-classes delq nil mapcar make-closure #[257 "\211\300>\205 \211\207" [V0] 3 "\n\n(fn X)"] " " make-string 46 "<" mapconcat identity "," ">" format "%s<%d classes>" copy-sequence put-text-property 0 help-echo idlwave--class-selector idlwave--method-selector idlwave--type-selector] 9 "\n\n(fn X)"]] 25 (#$ . 182499)])
#@13
(fn LIST)
(defalias 'idlwave-attach-method-classes #[257 "\301\302#\207" [idlwave-completion-show-classes idlwave-attach-classes method] 5 (#$ . 183779)])
#@13
(fn LIST)
(defalias 'idlwave-attach-keyword-classes #[257 "\301\302#\207" [idlwave-completion-show-classes idlwave-attach-classes kwd] 5 (#$ . 183944)])
#@13
(fn LIST)
(defalias 'idlwave-attach-class-tag-classes #[257 "\301\302#\207" [idlwave-completion-show-classes idlwave-attach-classes class-tag] 5 (#$ . 184107)])
#@174 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.
(fn EV LIST TITLE &optional SORT)
(defalias 'idlwave-popup-select #[1027 "\301\211\203; G\302U\203 @\262\202; \203 \303\304\"\262\305\306C\307\310\n\"\"CB\262\311\"\262\312\"\262\207" [idlwave-max-popup-menu-items nil 1 sort #[514 "\226\226\231\207" #1=[] 4 "\n\n(fn A B)"] append "" mapcar #[257 "\211B\207" #1# 3 "\n\n(fn X)"] idlwave-split-menu x-popup-menu] 13 (#$ . 184279)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias idlwave-split-menu-emacs idlwave-split-menu nil make-obsolete "28.1"] 4)
#@64 Split the MENU into submenus of maximum length N.
(fn MENU N)
(defalias 'idlwave-split-menu #[514 "A@GTX\203\f \207@A@A\300\301\300\203Z \2035 W\2035 T\262@B\262A\262\202 \211\237\262\302!\210\303\304@@S8@#B\262\211B\262\300\262\301\262\202 \237\262B\262\207" [nil 0 prin1 format "%s...%s"] 12 (#$ . 184969)])
(defvar idlwave-completion-setup-hook nil)
#@69 Scroll the completion window on this frame.
(fn &optional MESSAGE)
(defalias 'idlwave-scroll-completions #[256 "\302\303\304\"\305 \306\307\"\216\310!\210\3111 \312 0\210\2025 \210<\2030 \3138\2030 \310!\210 \210\2025 \314e\"\210\205= \315\316\")\207" [last-command idlwave--complete-after-success-function get-buffer-window "*Completions*" visible selected-window make-closure #[0 "\301\300!\207" [V0 select-window] 2] select-window (error) scroll-up 2 set-window-start message "%s"] 6 (#$ . 185365)])
#@119 Display the completions in LIST in the completions buffer and echo MESSAGE.
(fn LIST &optional MESSAGE BEG COMPLETE)
(defalias 'idlwave-display-completion-list #[1025 "\304\305!\203
\306\307\305\"\204 \310\223\210\311 \312!\210\313E\314\307\315\305#\210 \2031 @:\2031 \303 \210\316\317!\210\320\321\206< \322\"\207" [idlwave-completion-mark idlwave-before-completion-wconf this-command idlwave-completion-fontify-classes get-buffer-window "*Completions*" idlwave-local-value idlwave-completion-p nil current-window-configuration idlwave-display-completion-list-1 idlwave-display-completion-list idlwave-set-local t run-hooks idlwave-completion-setup-hook message "%s" "Making completion list...done"] 8 (#$ . 185886)])
#@86 Call FUNCTION as a completion chooser and pass ARGS to it.
(fn FUNCTION &rest ARGS)
(defalias 'idlwave-choose #[385 "\303\304\"\210)\305\306!\203 \204 \212\307\310x\210`)\311`\312#\266\n \207" [completion-ignore-case font-lock-mode idlwave--complete-after-success-force-function t apply derived-mode-p idlwave-shell-mode "a-zA-Z0-9_" nil remove-text-properties (face nil)] 7 (#$ . 186623)])
(defalias 'idlwave-keyboard-quit #[0 "\301\216\242\302=\205 \303 )\207" [last-command #[0 "\300 \207" [keyboard-quit] 1] 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 #[0 "\205 \205 \302 !\207" [idlwave-completion-restore-window-configuration idlwave-before-completion-wconf set-window-configuration] 2 (#$ . 187236)])
#@614 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.
(fn SYM PROMPT DELAY)
(defalias 'idlwave-one-key-select #[771 "J\306\307\211J\310N=\203 \311N\262\202+ \312!\262\313\311#\210\313\310#\210\314\315\316\317\320##\210\321!\203\220 \322 \323\324\"\216 r\325\326!q\210p\327 \210\307\211\330\211\330 \"\331 \210\332\333!\210+\211 #\211\203 \211@\334A@!\210\334\335!\210A\266\202\202h \210\336!\210)\266\337 \262)\210\202\224 \337 \262\314\307!\210\340\341\"8)\207" [temp-buffer-show-hook default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks (fit-window-to-buffer) nil :one-key-alist-last :one-key-alist-cache idlwave-make-one-key-alist put message "%s[%s]" mapconcat #[257 "\300@!\207" [char-to-string] 3 "\n\n(fn X)"] "" sit-for current-window-configuration make-closure #[0 "\301\300!\207" [V0 set-window-configuration] 2] 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 inhibit-read-only standard-output] 14 (#$ . 187507)])
#@53 Make an alist for single key selection.
(fn ALIST)
(defalias 'idlwave-make-one-key-alist #[257 "\211\301\211\211\211\211\302\301\203\372 @@\262A\262\3032\366 \304\305\"\203F \306\307\310\"\227!\262\311\312#\262EB\262\313\303\314\"\210\302\262\304\315#\203\217 \302\225\262\306\307\302\"\227!\262\316\"\204I \311\312\317\320\307\302 \"\321Q\314\211 $#\262EB\262\313\303\314\"\210\202I \302\262\304\322#\203\327 \302\225\262\306\307\302\"!\262\316\"\204\222 \311\312\317\320\307\302 \"\321Q\314\211 $#\262EB\262\313\303\314\"\210\202\222 \306\323T\211\262!!\262\311\312#\262EB\211\2620\210\202 \237)\207" [case-fold-search nil 0 exit string-match "\\[\\(.\\)\\]" string-to-char match-string 1 format "%c: %s" throw t "[A-Z]" assoc replace-match "[" "]" "[a-z]" int-to-string] 16 (#$ . 189178)])
#@88 Set the buffer-local value of VAR in BUFFER to VALUE.
(fn VAR VALUE &optional BUFFER)
(defalias 'idlwave-set-local #[770 "r\211\206 pq\210\300!L)\207" [make-local-variable] 5 (#$ . 190066)])
#@99 Return the value of VAR in BUFFER, but only if VAR is local to BUFFER.
(fn VAR &optional BUFFER)
(defalias 'idlwave-local-value #[513 "\300\"\205 \301\206 p\"\207" [local-variable-p buffer-local-value] 5 (#$ . 190267)])
#@60 Keymap for `completion-list-mode' with `idlwave-complete'.
(defvar idlwave-completion-map nil (#$ . 190500))
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias idlwave-display-completion-list-emacs idlwave-display-completion-list-1 nil make-obsolete "28.1"] 4)
#@69 Display completion list and install the choose wrappers.
(fn LIST)
(defalias 'idlwave-display-completion-list-1 #[257 "r\306\307!q\210p\310 \210\311\211\312\211\312 \313 \210\314\315!\210+\211 \316!\210\317!\210)\266r\307q\210\320\206> \321\322 !\211!)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only 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 current-local-map standard-output idlwave-completion-map] 6 (#$ . 190782)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias idlwave-make-modified-completion-map-emacs idlwave-make-modified-completion-map nil make-obsolete "28.1"] 4)
#@55 Replace `choose-completion' in OLD-MAP.
(fn OLD-MAP)
(defalias 'idlwave-make-modified-completion-map #[257 "\300!\301\302\303#\210\304\305\306#\210\207" [copy-keymap substitute-key-definition choose-completion idlwave-choose-completion define-key [mouse-3] idlwave-mouse-completion-help] 6 (#$ . 191647)])
#@69 Choose the completion that point is in or next to.
(fn &rest ARGS)
(defalias 'idlwave-choose-completion #[128 "\300\301\302#\207" [apply idlwave-choose choose-completion] 5 (#$ . 191963) (list last-nonmenu-event)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias idlwave-mouse-choose-completion idlwave-choose-completion nil make-obsolete "28.1"] 4)
#@74 Regexp for skipping continued blank or comment-only lines in structures.
(defvar idlwave-struct-skip "[ ]*\\(\\$.*\n\\(^[ ]*\\(\\$[ ]*\\)?\\(;.*\\)?\n\\)*\\)?[ ]*" (#$ . 192339))
#@28 Regexp for structure tags.
(defvar idlwave-struct-tag-regexp (concat "[{,]" idlwave-struct-skip "\\([a-zA-Z][a-zA-Z0-9_]*\\)[ ]*:") (#$ . 192528))
#@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 #[0 "\212\301 \211@A\302b\210\214}\210\303\304#\203@ \3051% \306\307!\210\3040\202) \210\2029 \2039 `U\2039 \310\311!B\262\312\225b\210\202 )\211\237\266\204)\207" [idlwave-struct-tag-regexp idlwave-struct-borders nil re-search-forward t (error) up-list -1 match-string-no-properties 5 0] 8 (#$ . 192683)])
#@63 Find a given TAG in the structure defined at point.
(fn TAG)
(defalias 'idlwave-find-struct-tag #[257 "\301 \211A\302\303\304\305Q\302#)\207" [case-fold-search idlwave-struct-borders t re-search-forward "\\(^[ ]*\\|[,{][ ]*\\)" "[ ]*:"] 7 (#$ . 193170)])
#@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 #[0 "\212\302 \211@A\303\304b\210\214}\210\305\306 \307 \310\260\303#\203H \3111- \312\313!\210\3030\2021 \210\202A \203A `U\203A \314\315!B\262\316\225b\210\202 )\211\237)\266\204)\207" [case-fold-search idlwave-struct-skip idlwave-struct-borders t nil re-search-forward "[{,]" "inherits" "\\([a-zA-Z][a-zA-Z0-9_]*\\)" (error) up-list -1 match-string-no-properties 9 0] 10 (#$ . 193439)])
#@58 Return t if point is inside an IDL structure definition.
(defalias 'idlwave-in-structure #[0 "`\212\300 \206 \301 ?\205, \302\303\211\304#\205, \305 \211@AU\206* @V\205* AW\262)\207" [idlwave-in-comment idlwave-in-quote idlwave-find-structure-definition nil back idlwave-struct-borders] 5 (#$ . 194015)])
#@61 Return the borders of the {...} after point as a cons cell.
(defalias 'idlwave-struct-borders #[0 "\300\212\301\300w\210`\262\3021 \303\304!0\210\202 \210\211b\210\211`)B\207" [nil "^{" (error) forward-list 1] 3 (#$ . 194333)])
#@444 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.
(fn &optional VAR NAME BOUND)
(defalias 'idlwave-find-structure-definition #[768 "\301\211\250\205 \211\203 \302\303\227!\304Q\202 \305\306\203- ;\203) \307\227\310Q\202. \311\202. \312Q\313=\204; \314=\203C \315\316\301#\204R \314=?\205Y \317\301#\205Y \320\224b\210\321\322!)\207" [case-fold-search t "\\<" regexp-quote "\\>[ ]*\\(\\$.*\n[ ]*\\)*" "\\(\\)" "=[ ]*\\(\\$.*\n[ ]*\\)*\\({\\)" "[ ]*\\(\\$.*\n[ ]*\\)*\\(\\<" "\\)[^a-zA-Z0-9_$]" "[ ]*\\(\\$.*\n[ ]*\\)*\\<\\([a-zA-Z_0-9$]+\\)[ ]*\\(\\$.*\n[ ]*\\)*," "" all back re-search-backward nil re-search-forward 3 match-string-no-properties 5] 9 (#$ . 194571)])
(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 #[0 "\301\211\207" [idlwave-class-reset t] 2] idlwave-after-load-rinfo-hook #[0 "\301\211\207" [idlwave-class-info nil] 2]] 3)
#@14
(fn CLASS)
(defalias 'idlwave-class-info #[257 "\303\211\203 \203/ \303\304\303\305\306\"\"\202/ \n\211\262\211A\262\242\211\262\203/ \307!\210\202 \310!\262\236\206A \311!\210\236\207" [idlwave-class-info idlwave-class-reset idlwave-system-class-info nil delq mapcar #[257 "\300\301\236A\206\n @!\211A?\205 \207" [idlwave-class-file-or-buffer found-in] 4 "\n\n(fn X)"] idlwave-sintern-class-info idlwave-sintern-class idlwave-scan-class-info] 9 (#$ . 195912)])
#@60 Sintern the class names in a class-info entry.
(fn ENTRY)
(defalias 'idlwave-sintern-class-info #[257 "\300\236\301@\302\"\240\210\211\205 \211\303\304A\"\241\207" [inherits idlwave-sintern-class set mapcar #[257 "\300\301\"\207" [idlwave-sintern-class set] 4 "\n\n(fn X)"]] 6 (#$ . 196406)])
#@314 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.
(fn CLASS &optional ALL-HOOK ALT-CLASS)
(defalias 'idlwave-find-class-definition #[769 "\301\302\211\303\304\227\305Q\302\301#\2059 \2030 \212\306 \210`)\262\307\302\301#\211\262\2059 !\210\202 \307\302\2068 \")\207" [case-fold-search t nil re-search-forward "^[ ]*pro[ ]+" "__define\\>" idlwave-end-of-subprogram idlwave-find-structure-definition] 10 (#$ . 196713)])
#@52 Find buffer visiting CLASS definition.
(fn CLASS)
(defalias 'idlwave-class-file-or-buffer #[257 "\211\227\300P\301\302\303\304\305\306 $8!\211\205 \307!B\207" ["__define" idlwave-routine-source-file 3 idlwave-rinfo-assoc pro nil idlwave-routines find-buffer-visiting] 9 (#$ . 197376)])
#@79 Scan all class and named structure info in the class__define pro.
(fn CLASS)
(defalias 'idlwave-scan-class-info #[257 "\301\302!\211@A\303!?\206 ?\205 \304!??\205J \212\203) q\210\202> \305\306!q\210\307 \210\310\311!\204: \311 \210\312!\210\212\313b\210\314\315\316\"\"*)\207" [idlwave-auto-routine-info-updates 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 make-closure #[257 "\302!\211\303\304 B\305\306 BE\300=\204 \211\307\300BC\244\262\310!\210\211 B\211\207" [V0 idlwave-class-info idlwave-sintern-class tags idlwave-struct-tags inherits idlwave-struct-inherits found-in idlwave-sintern-class-info] 6 "\n\n(fn NAME)"]] 10 (#$ . 197673)])
#@56 Return the FOUND-IN property of the CLASS.
(fn CLASS)
(defalias 'idlwave-class-found-in #[257 "\300\301!\236A\207" [found-in idlwave-class-info] 4 (#$ . 198498)])
#@46 Return the native tags in CLASS.
(fn CLASS)
(defalias 'idlwave-class-tags #[257 "\300\301!\236A\207" [tags idlwave-class-info] 4 (#$ . 198669)])
#@54 Return the direct superclasses of CLASS.
(fn CLASS)
(defalias 'idlwave-class-inherits #[257 "\300\301!\236A\207" [inherits idlwave-class-info] 4 (#$ . 198822)])
#@66 Return a list of native and inherited tags in CLASS.
(fn CLASS)
(defalias 'idlwave-all-class-tags #[257 "\3001 \301\302\303\304\305!B\"\"0\207\306 \210\307\310\311!\"\207" [(error) apply append mapcar idlwave-class-tags idlwave-all-class-inherits idlwave-class-tag-reset error "%s" error-message-string] 8 (#$ . 198991)])
#@142 Return a list of all superclasses of CLASS (recursively expanded).
The list is cached in `idlwave-class-info' for faster access.
(fn CLASS)
(defalias 'idlwave-all-class-inherits #[257 "\204 \301\207\211\302\267\202 \301\207\301\207\303!\301\304\236\211\262\203 \211A\207\305\306\307!\"\301\211\211C\203] \211\211A\262\242\240\210\211\242@B\262\310\305\311\312\"\307\242@!\"\"\262\211\242A\313V\203* \314\315!\210\202* \237\262\304BC\244\210\207" [idlwave-support-inheritance nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 12 t 14)) idlwave-class-info all-inherits mapcar #[257 "\211\300B\207" [0] 3 "\n\n(fn X)"] idlwave-class-inherits append make-closure #[257 "\211\300\242ATB\207" [V0] 3 "\n\n(fn X)"] 999 error "Class scan: inheritance depth exceeded. Circular inheritance?"] 12 (#$ . 199326)])
#@201 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.
(fn ENTRY &optional RECORD-LINK)
(defalias 'idlwave-entry-keywords #[513 "\300C\301\302\303#\304\233\"\210\211\242\237\207" [nil mapc make-closure #[257 "\211@\302\303\304\300\301$A\"\207" [V0 V1 mapcar make-closure #[257 "\211@A\300\203& \302\203& \304!\262\305\306G\307\302\205! \310!PP%\210\301C\301\242B\240\207" [V0 V1 V2 idlwave-html-link-sep copy-sequence put-text-property 0 link number-to-string] 11 "\n\n(fn KEY-CONS)"]] 8 "\n\n(fn KEY-LIST)"] 5] 8 (#$ . 200203)])
#@89 Find keyword KEYWORD in entry ENTRY, and return (with link) if set.
(fn ENTRY KEYWORD)
(defalias 'idlwave-entry-find-keyword #[514 "\3002 \301\302\303\"\304\233\"0\207" [exit mapc make-closure #[257 "\211@\302\300A\"\211\205) \211@\203 A\203 \303A!Q\202\" AB\262\304\305\"\207" [V0 idlwave-html-link-sep assoc number-to-string throw exit] 8 "\n\n(fn KEY-LIST)"] 5] 6 (#$ . 200867)])
(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)
(defvar idlwave-sint-class-tags nil)
#@27
(fn NAME &optional SET)
(defalias 'idlwave-sintern-class-tag #[513 ";\204 \207\301\227\"A\206 \211\203 \227BB\207\207" [idlwave-sint-class-tags assoc] 5 (#$ . 201472)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [add-hook idlwave-complete-functions idlwave-complete-class-structure-tag 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 #[0 "`\306\212\307\310x\210`\311ZW\205 \312\313!)\205P \314\315 8\316 ! \204( \317\320!\210 \232\2042 \321 !\210\322\323 \324P!\310E
\210\310\325\326\211\310\327\330 \"\331\332&\266*\306)\207" [case-fold-search idlwave--class-selector idlwave--super-classes idlwave-current-tags-class idlwave-completion-help-info idlwave-current-native-class-tags 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-class-tags] 10 (#$ . 201840) nil])
(defalias 'idlwave-class-tag-reset #[0 "\301\211\207" [idlwave-current-tags-class nil] 2])
#@86 Find and parse the necessary class definitions for class structure tags.
(fn CLASS)
(defalias 'idlwave-prepare-class-tag-completion #[257 "\304\211\305\306\307!\"\305\310\311!\"\211\207" [idlwave-sint-class-tags idlwave-current-tags-class idlwave-current-class-tags idlwave-current-native-class-tags nil mapcar #[257 "\300\301\"C\207" [idlwave-sintern-class-tag set] 4 "\n\n(fn X)"] idlwave-all-class-tags downcase idlwave-class-tags] 5 (#$ . 202836)])
(defvar idlwave-sint-sysvars nil)
(defvar idlwave-sint-sysvartags nil)
(defvar idlwave-sint-sysvars nil)
#@27
(fn NAME &optional SET)
(defalias 'idlwave-sintern-sysvar #[513 ";\204 \207\301\227\"A\206 \211\203 \227BB\207\207" [idlwave-sint-sysvars assoc] 5 (#$ . 203408)])
(defvar idlwave-sint-sysvartags nil)
#@27
(fn NAME &optional SET)
(defalias 'idlwave-sintern-sysvartag #[513 ";\204 \207\301\227\"A\206 \211\203 \227BB\207\207" [idlwave-sint-sysvartags assoc] 5 (#$ . 203629)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\207" [add-hook idlwave-complete-functions idlwave-complete-sysvar-or-tag 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 #[0 "`\303\212\304\305x\210`Sf)\306=\203! \307\310\311\211\n\305\312\313&\210\303\202n \212\314\305x\210`Sf\306=\2058 \315\316!\2058 \317\225X)\203m \320\321\322!!\211\n\236\323\236A\204Q \324\325\"\210\211\204Z \324\326\"\210\327D\310\330\211\305\331\332&\266\303\202n \305)\207" [case-fold-search idlwave-completion-help-info idlwave-system-variables-alist 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"] 11 (#$ . 204066) nil])
#@18
(fn MODE WORD)
(defalias 'idlwave-complete-sysvar-help #[514 "A@\206 \211\303 \"\304\267\202, ;\205/ \211\205/ \305\236A@\207\211\205/ \305\236A@\211\207\306\307!\207" [idlwave-completion-help-info idlwave-system-variables-alist idlw-help-link assoc #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (test 17 set 32)) link error "This should not happen"] 6 (#$ . 204956)])
#@18
(fn MODE WORD)
(defalias 'idlwave-complete-sysvar-tag-help #[514 "A@\303 \"\304\236A\305\236A@\306\307\267\202? ;\205B \205B \207\205B \310\311#A\211\262\203; \312\"\202< \211\207\313\314!\207" [idlwave-completion-help-info idlwave-system-variables-alist idlw-help-link assoc tags link nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (test 24 set 35)) assoc-string t idlwave-substitute-link-target error "This should not happen"] 11 (#$ . 205380)])
#@58 Split a given LINK into link file and anchor.
(fn LINK)
(defalias 'idlwave-split-link-target #[257 "\301\"\205 \211\302\211\224O\303\302\225\304O!B\207" [idlwave-html-link-sep string-match 0 string-to-number nil] 6 (#$ . 205896)])
#@68 Substitute the TARGET anchor for the given LINK.
(fn LINK TARGET)
(defalias 'idlwave-substitute-link-target #[514 "\301\302\303\"\203 \304\211\224O\202 \262\203 \211\305!Q\207\207" [idlwave-html-link-sep nil string-match "#" 0 number-to-string] 7 (#$ . 206138)])
(defvar idlwave-help-do-class-struct-tag nil)
#@18
(fn MODE WORD)
(defalias 'idlwave-complete-class-structure-tag-help #[514 "\305\267\202@ \306\207\306\211\307\"\211\262\2038 \310! \236\203 \311\312!\210\313!\211\262\2034 \211\314PB\266\202: \314P\266\211\315\211\207\311\316!\207" [idlwave-current-tags-class idlwave-system-class-info idlw-help-name idlw-help-link idlwave-help-do-class-struct-tag #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (test 6 set 8)) nil 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"] 7 (#$ . 206465)])
#@101 Find and return the CLASS or one of its superclass with the
associated TAG, if any.
(fn CLASS TAG)
(defalias 'idlwave-class-or-superclass-with-tag #[514 "\300!B\301\3022> \205= \211A\262\242\262\303!\211\2039 \304\305\301@\305\301\306&\306=\2032 \307\302\"\210\211A\262\202 \210\202\n 0\207" [idlwave-all-class-inherits nil exit idlwave-class-tags compare-strings 0 t throw] 13 (#$ . 207131)])
(defalias 'idlwave-sysvars-reset #[0 "\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 #[0 "\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 #[0 "\301\211\211A\262\242\211\262\205+ \302@\303\"\240\210\304\236\262\211\203 \211\305\306A\"\241\210\202 \207" [idlwave-system-variables-alist nil idlwave-sintern-sysvar set tags mapcar #[257 "\300@\301\"AB\207" [idlwave-sintern-sysvartag set] 4 "\n\n(fn X)"]] 7])
#@40 Get any new system variables and tags.
(defalias 'idlwave-shell-filter-sysvars #[0 "\302 \303\211\211\211C\303\304\305#\203O \302\225\262\306\307\"\262\310\225\205+ \311\306\310 \"!\262\211\312!\236\240\210\313\242\236\262\314\315\316\317\"\"BE B\202\n \206T \211\207" [idlwave-shell-command-output idlwave-system-variables-alist 0 nil string-match "^IDLWAVE-SYSVAR: !\\([a-zA-Z0-9_$]+\\)\\( \\(.*\\)\\)?" match-string 1 3 idlwave-split-string idlwave-sintern-sysvar link tags mapcar make-closure #[257 "\211\301!\302\300\242\236A\236AB\207" [V0 idlwave-sintern-sysvartag tags] 5 "\n\n(fn X)"]] 13 (#$ . 208298)])
#@59 Goto the *Completions* buffer and fontify the class info.
(defalias 'idlwave-completion-fontify-classes #[0 "r\301q\210\212eb\210\302\303\304\302\305#\205 \306\307\224\307\225\310\311$\210\202\n +\207" [buffer-read-only "*Completions*" nil re-search-forward "\\.*<[^>]+>" t put-text-property 0 face font-lock-string-face] 5 (#$ . 208945)])
#@164 Add `=' or `(' after successful completion of keyword and function.
Restore the pre-completion window configuration if possible.
(fn TYPE SLASH &optional VERIFY)
(defalias 'idlwave-after-successful-completion #[770 "\304=\204< \305\267\202< \203< \306=\204 \307=\203\" \310c\210\202< \311=\203< \312c\210\313u\210\202< \203< \204< \314c\210\211\315=\204_ \316\317!\203b \320\321\317\"\203b \322\n!p=\203b \323\n!\232\203b \324 \210\n\325\211\223\210\325\211\207" [idlwave-function-completion-adds-paren idlwave-keyword-completion-adds-equal idlwave-completion-mark idlwave-before-completion-wconf procedure #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (function 12 keyword 49)) t 1 "(" 2 "()" -1 "=" force get-buffer-window "*Completions*" idlwave-local-value idlwave-completion-p marker-buffer marker-position idlwave-restore-wconf-after-completion nil] 6 (#$ . 209294)])
#@77 Call `idlwave-context-help' on the clicked location.
(fn EV &optional ARG)
(defalias 'idlwave-mouse-context-help #[513 "\300!\210\301!\207" [mouse-set-point idlwave-context-help] 4 (#$ . 210225) "eP"])
(defvar idlwave-last-context-help-pos nil)
#@462 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.
(fn &optional ARG)
(defalias 'idlwave-context-help #[256 "\300!\207" [idlwave-do-context-help] 3 (#$ . 210480) "P"])
#@61 Display online help about the completion at point.
(fn EV)
(defalias 'idlwave-mouse-completion-help #[257 "\302!\207" [last-command this-command idlwave-do-mouse-completion-help] 3 (#$ . 211046) "eP"])
#@483 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.
(fn &optional ARG EXTERNAL)
(defalias 'idlwave-routine-info #[512 "\302 \210\303\304e`S]\305`\\d^{\"\203A \306`\307\"\203= \2035 \212\310u\210\311\312!\2053 \313\314\224\314\225\315#\210\316\317!)\207\316\320\306`\307\"\"\207\316\321!\207\322\323\232\324 \211@\203W \325\326\327!\"\202Z \330\331!*\207" [idlwave-query-class idlwave-force-class-query idlwave-routines string-search "->" 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"] 7 (#$ . 211259) "P"])
#@463 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.
(fn &optional ARG)
(defalias 'idlwave-resolve #[256 "\302\211\303\232\304 \305\3068@\"A@\307=\203 \310\202 \311\312\313\314\315#\"\316\302\317\320\"\203E \321\322\"\262\306\224\205= \321\323\"\262\321\324\"\262\227\311\230\203O \325\262\211\204b \326\314\327\227#\330\302\331$\202z \326\314\332\227#\326\314\333\227\n\227$\334\302\331\257\"*\207" [idlwave-query-class idlwave-force-class-query 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)] 15 (#$ . 212535) "P"])
(defalias 'idlwave-find-module-this-file #[0 "\300\301!\207" [idlwave-find-module (4)] 2 nil nil])
#@298 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.
(fn &optional ARG)
(defalias 'idlwave-find-module #[256 "\302\211\303\232\211\304\232\305\306 !\211\203) \307\3108@\"A@\311=\203$ \312\202% \313P\202* \314\315\316\302\317\320\2039 \321 \202; \322 \"\"!\323\203J \324\"\203Q \325\326\"\202R \327\"\302\211\330\331\"\203` \262\330\332\"\203s \333\334O\262\335\336O\262\330\337\"\203\206 \340\341\"\262\340\310\"\262\342\"\262\343!\262\344\267\202\237 \345\202\240 \311\202\240 \346\262\347\302 %*\207" [idlwave-query-class idlwave-force-class-query 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 #[257 "\3008\242\301=?\205 \302\3038@\"A@\304=\203 \305\202 \306PC\207" [3 system idlwave-make-full-name 2 pro "<p>" "<f>"] 4 "\n\n(fn X)"] idlwave-save-buffer-update idlwave-routines idlwave-completing-read assoc format-prompt "Module" "Module in this file: " string-match "\\`\\s-*\\'" "<[fp]>" -2 -1 0 -3 "\\(.*\\)::\\(.*\\)" match-string 1 idlwave-sintern-routine-or-method idlwave-sintern-class #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("f" 151 "p" 155)) fun t idlwave-do-find-module] 14 (#$ . 213922) "P"])
#@59
(fn NAME TYPE CLASS &optional FORCE-SOURCE THIS-BUFFER)
(defalias 'idlwave-do-find-module #[1283 "\301\"\302\211\211p`\302\211\303
\304 \305%\262 \206! \3068\262\3078\2034 \301\3078\"\2026 \262\203C \310!\262\204_ \311 \203V \312\313
\227\"\202\\ \312\314\227\"!\262\f\203k \f\315\232\203o \316\317!\207@\320=\203| \316\321\"\207\203\206 \322!\204\213 \316\323\"\207\204\234 \324\325\"\262\326\327\"\210db\210\327\330\331
\332\267\202\262 \333\202\263 \334\202\263 \335\336\337\227!\340\260\302\327#\203\307 \341\224b\202\322 \326!\210b\210\316\342\")\207" [case-fold-search 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 "^[ ]*\\<" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (fun 170 pro 174)) "function" "pro" "\\(pro\\|function\\)" "\\>[ ]+" regexp-quote "[^a-zA-Z0-9_$]" 0 "Could not find routine %s"] 19 (#$ . 215446)])
#@105 Return a default module for stuff near point.
Used by `idlwave-routine-info' and `idlwave-find-module'.
(defalias 'idlwave-what-module #[0 "\301 \210\302\212\303 \210\304\305!*\203- \306\307\310!\307\311!\"\312\313!\227\314\232\203% \315\202& \316\317\312\320!!E\207\321 \3118@@A@@\322\323!\212\323\324w\210g)\325=\203h \326\232\204h \306\311\320 88\"\262\315\327\320\n8AB\315\"E\207\330=\203\231 \326\232\204\231 \211\331=\204\200 \304\332!\203\231 \306\311\320 88\"\262\316\327\320\n8AB\316\"E\207\333>\203\265 \326\232\204\265 \211\331=\203\265 \334!\262\316\324E\207\203\304 \316\327A@\316\"E\207\203\322 \315\327@\315\"E\207\266\324\207" [case-fold-search 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" 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] 12 (#$ . 216706)])
#@71 Call `idlwave-what-module' and find the inherited class if necessary.
(defalias 'idlwave-what-module-find-class #[0 "\300 \3018G\302U\203 \211;\203 @A@\303\304\"E\207\207" [idlwave-what-module 2 3 apply idlwave-find-inherited-class] 7 (#$ . 217887)])
#@98 Find the class which defines TYPE NAME and is CLASS or inherited by CLASS.
(fn NAME TYPE CLASS)
(defalias 'idlwave-find-inherited-class #[771 "\300\301 $\211\203 \3028\207\207" [idlwave-best-rinfo-assoc idlwave-routines 2] 8 (#$ . 218152)])
#@140 Check if MODULE points to obj_new.
If yes, and if the cursor is in the keyword region, change to the
appropriate Init method.
(fn MODULE)
(defalias 'idlwave-fix-module-if-obj_new #[257 "\211@`\301\302;\2032 \227\303\232\2032 \212\304 \210`{\262\305\306\")\2032 \307\310\"\311\312!\313\314!E\262\210)\207" [case-fold-search t nil "obj_new" idlwave-beginning-of-statement string-match "obj_new([^'\"]*['\"]\\([a-zA-Z0-9_]+\\)" match-string 1 idlwave-sintern-method "Init" fun idlwave-sintern-class] 9 (#$ . 218407)])
#@258 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.
(fn NAME TYPE CLASS KEYWORDS &optional SUPER-CLASSES SYSTEM)
(defalias 'idlwave-fix-keywords #[1540 "C\304\226\305\232\203Q \306\307\310\"\203Q \212\311 \210`)\211`{\304\312\313\314\"\203N \315\316\317\"!\211\262\203N \211\211\203N \320\242\321\322\323\324!\325\326 $\327\"\"\240\210)\266\304=\203m \330\331\332#\333 \326 \"\"\210\211\334\242!\240\210\203\376 \203\376 ;\203\376 \204\220 \335\336!\242\236\204\220 \335\337!\242\236\203\376 \312\3402\263 \211A\262\242\211\262\205\262 \313\n\"\203\226 \341\340\304\"\210\202\226 0\266\202\203\376 \326 \312:\203\365 @\262\3428\203\356 \3428>\203\356 \211A@=\203\356 \211@ =\203\356 \330\331\343\"\321\327\"\"\210A\262\202\273 \266\211\334\242!\240\210\211\242*\207" [idlwave--super-classes case-fold-search idlwave-current-obj_new-class idlwave-keyword-class-inheritance 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 make-closure #[257 "\3028\205 \211A@\300=\205 \301\303\301\242\304\305\"\"\240\207" [V0 V1 2 append idlwave-entry-keywords do-link] 7 "\n\n(fn ENTRY)"] idlwave-all-assq idlwave-uniquify idlwave-sintern-keyword "_extra" "_ref_extra" exit throw 2 #[257 "\211\300\242\235\203\n \300\242\207\300\300\242B\240\207" [V0] 4 "\n\n(fn K)"]] 19 (#$ . 218940)])
#@653 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.
(fn KEYWORD MODULE)
(defalias 'idlwave-expand-keyword #[514 "\211@A@\3018\302!\303\304 $\305!\302\306!\236\206\" \302\307!\236\310\311\236\203/ \202` \312\"\211\262\203I \211G\313U\203E \211@\202` \211\202` \203V \203V \202` \203^ \311\202` )\207" [completion-ignore-case 2 idlwave-sintern-keyword idlwave-best-rinfo-assoc idlwave-routines idlwave-entry-keywords "_EXTRA" "_REF_EXTRA" t nil all-completions 1] 13 (#$ . 220667)])
(defvar idlwave-rinfo-mouse-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\207" [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] 5))
(defvar idlwave-rinfo-map (byte-code "\300 \301\302\303#\210\207" [make-sparse-keymap define-key "q" idlwave-quit-help] 5))
(defvar idlwave-popup-source nil)
(defvar idlwave-rinfo-marker (make-marker))
(defalias 'idlwave-quit-help #[0 "\300\301!\300\302!\211\203 \303\304!\203 \305!\210\304 \210\306!\205! \307\310\"\207" [get-buffer-window "*Help*" "*IDLWAVE Help*" fboundp idlwave-help-quit select-window window-live-p quit-window nil] 5 nil nil])
#@48
(fn NAME TYPE CLASS &optional INITIAL-CLASS)
(defalias 'idlwave-display-calling-sequence #[1027 "\211\206 \306\307 $\206 \310$\211@\206 \3118\206\" \312!\313!\314!\211\3158@\316=\3178\320 \321\"\322\n8@\323\324C \fp\325\257\326\325C\325C\325\211\211\327$\262 \204~ \330\331\203{ \332P\202| \333$\207\203\212 \333\232\203\216 \330\334!\207 \204\233 \330\335#\207 `\325\223\210r\336\337!q\210\340\n!\210\325\341 \210\342\304!\210\325\342\305!\210
\203$\343\344\345@\346\347\350\351B\257\240\210B\325\352c\210\211A\262\242\211\262\203 \353c\210`\240\210\211c\210\211\227\227\232\203\354\242`\355\356D#\210\202\332 \310\307 $\203\332 \354\242`\242#\210\202\332 \357c\266\343\344\345@\346\360\350\361B\257\240\210 \203H\362\355\326\363F\242\"\240\210\364c\210`\240\210\203h\365\f&\202q\365\f\211\211\211%\357\261\210\354\242`\242#\210\366c\210\n\204\214\367c\210\202\250\370\240\210\371\372\373\f\f\f\f\f\f&\f\"\210\374\262G\262
\211A\262\242\211\262\2033\343\344\345@\346\375\376\311 8@@ A@\325\311 8@AF\350\376B\257\n\240\210\377\365\201C \374=\203\376\374V\203\370\201D \202\377\201E \202\377\333\374V\203 \201F \202\f\333#\242#\210T\262
\203\260AV\203\260\365\201G A\"c\210\325\262\202\260eb\210\201H )\201I \337!\210\201J \337!\211\262\205yB\205y\201K \372\201L \"\216\201M !\210\201N \201O \311\245\201P Z!\210\201Q )\262\207" [idlwave-unresolved-routines idlwave-rinfo-marker idlwave-rinfo-map buffer-read-only idlwave-popup-source idlwave-current-obj_new-class 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 " 0 nil 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 mouse-face highlight local-map help-echo "Button2: Display info about same method in superclass" data class "Classes: " " " add-text-properties face bold "\n" "Button2/3: Online Help" usage append link "Usage: " format "Keywords:" " No keywords accepted." 9 mapc make-closure #[257 "\302\242T@G\\\307 Y\203 \310c\210\302\311\240\210\312c\210\305`\240\210\306\313\314\315\316\317\303B\320\301\317\n@\257\n\240\210\300\203= \306\321\322\304D\306\242\"\240\210\211@c\210\323\305\242`\306\242#\210\302\211\242T@G\\\240\207" [V0 V1 V2 V3 V4 V5 V6 window-width "\n " 9 " " mouse-face highlight local-map data keyword help-echo append face add-text-properties idlwave-rinfo-mouse-map] 12 "\n\n(fn X)"] 1 "Button2: Jump to source and back | Button3: Source in Help window." source idlwave-insert-source-location idlwave-rinfo-mouse-map idlwave-rinfo-max-source-lines idlwave-resize-routine-help-window "\n%-8s %s" "Sources:" "Source:" "- " "\n Source information truncated to %d entries." t display-buffer get-buffer-window selected-window #[0 "\301\300!\207" [V0 select-window] 2] select-window enlarge-window frame-height window-height shrink-window-if-larger-than-buffer] 38 (#$ . 222578)])
#@171 Insert a source location into the routine info buffer.
Start line with PREFIX. If a file name is inserted, add FILE-PROPS
to it.
(fn PREFIX ENTRY &optional FILE-PROPS)
(defalias 'idlwave-insert-source-location #[770 "@A@\3008\301\236\302\236\303\236\304\236\203 \305\302\"\2069 \203, \305\303\"\2069 \211\2038 \305\304\"\2069 \306\307\310\211
c\210\n\311\267\202Y \310\262\312c\210\202\312 \310\262\313c\210\202\312 \204i \203i \314c\210\202\312 \204t \315c\210\202\312 \316\n!\203\221 \317\320\321\f!\"\203\213 \322c\210\202\312 \323c\210\202\312 A\206\230 A\211\262\203\247 \324\325\"c\210\202\312 \326\n!\211\262\203\272 \324\325\"c\210\202\312 \327\n!\203\307 \330c\210\202\312 \331c\210\203\373 \332\203\327 \333\202\330 \334\203\341 \335\202\342 \334\n\203\353 \336\202\354 \334\n\203\365 \337\202\366 \334\340\260c\210\306V\203`\262\324\341\"c\210\342`\343\344D#\210 \2055 \345\232?\2055`\262\346\347 C\"c\210 \2055\342`#\207" [2 compiled buffer user lib idlwave-count-memq 1 t nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (system 71 builtin 80)) "System " "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] 20 (#$ . 225948)])
#@138 Check the path of FILE against the regexps which define special libs.
Return the name of the special lib if there is a match.
(fn FILE)
(defalias 'idlwave-special-lib-test #[257 "\301\211;\203' \211A\262\242\211\262\203& \302@\"\203 A\262\301\262\202 \207\301\207" [idlwave-special-lib-alist nil string-match] 7 (#$ . 227449)])
#@11
(fn EV)
(defalias 'idlwave-mouse-active-rinfo-right #[257 "\300\301\"\207" [idlwave-mouse-active-rinfo right] 4 (#$ . 227796) "e"])
#@11
(fn EV)
(defalias 'idlwave-mouse-active-rinfo-shift #[257 "\300\301\302#\207" [idlwave-mouse-active-rinfo nil shift] 5 (#$ . 227937) "e"])
(defalias 'idlwave-active-rinfo-space #[0 "\300\301\302\"\207" [idlwave-mouse-active-rinfo nil right] 3 nil nil])
#@168 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.
(fn EV &optional RIGHT SHIFT)
(defalias 'idlwave-mouse-active-rinfo #[769 "\203 \305!\210\306\211\211\211\211\211\211\211\211\211\211\211\307`\310\"\262\f\307`\311\"\262\307`\312\"\262\307`\313\"\262 @\262 A@\262\n\314\f8\262 \315\f8\262\316\f8\262\317\f8\262\320 \262\321\322\"\262\n\323\267\202\377 \324!\203m \325!\210\326\327 !\n\330!$\207\331 $\207
\203\245 \332\306 \333\257C\334\n\n\n\306$+\207 ?\211\203\320 \3351\274 \336\n\n\n$0\207\306\324!\203\312 \325!\210\337A@!\207\203\334 \325!\210\202\341 \340!\210\341\f!b\207
\203\367 \331 %\207\342#\207\306\207" [idlwave-routines idlwave-help-source-try-header idlwave-extra-help-function idlwave-popup-source idlwave-rinfo-marker mouse-set-point nil get-text-property data source keyword link 2 3 4 6 idlwave-this-word get-buffer-window t #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (class 97 usage 122 source 132 keyword 230)) window-live-p select-window idlwave-display-calling-sequence idlwave-sintern-method idlwave-sintern-class idlwave-online-help idlwave-help-with-source "" idlwave-help-get-special-help (error) idlwave-do-find-module error pop-to-buffer marker-position idlwave-rinfo-insert-keyword] 23 (#$ . 228200) "e"])
#@108 Insert KEYWORD in BUFFER. Make sure buffer is displayed in a window.
(fn KEYWORD BUFFER &optional SHIFT)
(defalias 'idlwave-rinfo-insert-keyword #[770 "\302!\203 \227\262\211\203 \303!\210\202 \304!\210\302!\262h\305=\203( c\207\212\306\307`\310Ze^\311#)\2049 \312c\210\203@ \313c\210c\210?\205N \205N \314c\207" [idlwave-complete-empty-string-as-lower-case idlwave-keyword-completion-adds-equal get-buffer-window select-window pop-to-buffer 47 re-search-backward "[(,][ ]*\\(\\$[ ]*\\(;.*\\)?\n\\)?[ ]*\\=" 100 t ", " "/" "="] 8 (#$ . 229654)])
#@91 List the load path shadows of all routines defined in current buffer.
(fn &optional ARG)
(defalias 'idlwave-list-buffer-load-path-shadows #[256 "\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"] 5 (#$ . 230227) nil])
#@318 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.
(fn &optional ARG)
(defalias 'idlwave-list-shell-load-path-shadows #[256 "\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"] 5 (#$ . 230662) nil])
#@82 List the load path shadows of all routines known to IDLWAVE.
(fn &optional ARG)
(defalias 'idlwave-list-all-load-path-shadows #[256 "\300\301\211\302#\207" [idlwave-list-load-path-shadows nil "globally"] 5 (#$ . 231346) nil])
#@69 Internal variable used to influence `idlwave-routine-twin-compare'.
(defvar idlwave-sort-prefer-buffer-info t (#$ . 231579))
#@457 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.
(fn ARG &optional SPECIAL-ROUTINES LOC)
(defalias 'idlwave-list-load-path-shadows #[769 "\306 \210\204 \204 \307\310!\204 \311\312!\210\313\n \f\314&\315 \316\317\320\321\322\257\206- G\211\323\245\324\211\314\211 \314\211\211\211\211\211\203I
\262\262\325\326!\210\327\330\"\262\325\331!\210\332
\333\334#\210\332
\335\336#\210\325\337!\210r\340\341!q\210\314>\342 \210
\211A\262\242\211\262\203<\343 T\211\262 \"\324U\203\236 \325\344\345 \346_\"\"\210\347\206\247 \"\262>\203\267 \314\262\202\275 \350!\262\313\"\262G\351V\204\362 \352\353\354@8\"\351V\204\362 \352\355\354@8\"\351V\204\362 \352\356\354@8\"\351V\203v T\262\357\360\361\354\n8\n@\" A@\362=\203\363\202\364#c\210\211A\262\242\211\262\203v \313\365@ A@\354 8ED
\"\262\366\367#\210\202eb\210\370>)\206I\364\262\324V\203m\371\372\341!!\210\325\373 \211\351U\203f\364\202g\374$\202r\325\375\")\207" [idlwave-user-catalog-routines idlwave-library-catalog-routines idlwave-system-routines idlwave-compiled-routines idlwave-buffer-routines idlwave-sort-prefer-buffer-info idlwave-routines y-or-n-p "You don't have any user or library catalogs. Continue anyway? " error "Abort" append nil make-sparse-keymap mouse-face highlight local-map help-echo "Mouse2: Find source" 100 0 message "Sorting routines..." sort #[514 "\300\3018@\"\227\300\3018@\"\227\231\207" [idlwave-make-full-name 2] 6 "\n\n(fn A B)"] "Sorting routines...done" define-key [(mouse-2)] #[257 "\300!\210\301\302\303`\304\"\"\207" [mouse-set-point apply idlwave-do-find-module get-text-property find-args] 6 "\n\n(fn EV)" "e"] [(return)] #[0 "\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%%)" floor 100.0 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" buffer-read-only] 24 (#$ . 231711)])
#@16
(fn ROUTINE)
(defalias 'idlwave-print-source #[257 "\3008\211@\301!\302!\203 \303\262\304=\203& \211;\203# \305\306\"\204& \307\262\310\311\312\2032 \2023 \313#!\207" [3 idlwave-routine-source-file idlwave-syslib-p syslib compiled string-match "\\S-" unresolved princ format " %-10s %s\n" "No source code available"] 9 (#$ . 234337)])
#@234 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.
(fn ENTRY &optional LIST)
(defalias 'idlwave-routine-twins #[513 "@A@\3018\302\206 \303 \"\304\211\211A\262\242\211\262\203> \211=\204 A@=\203 \3018=\203 \211B\262\202 \305$\211\262\203R \211B\262\237B\207" [idlwave-unresolved-routines 2 idlwave-all-assq idlwave-routines nil idlwave-rinfo-assq] 13 (#$ . 234697)])
#@369 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.
(fn ENTRIES)
(defalias 'idlwave-study-twins #[257 "\211@\211@\211A@\3028\303\304\211\211\211\211\211 \211A\262 \242\211\262\n\203\217 T\262\305 8\262@\262\3058B\262\306!\262\307=\203J \202U \203T \310!\202U \311\262\203h \204h \312!\203h \313\262\314\"\211\262\n\203\202 AA\211@B\240\266\202 \211CEB\262\202 \237\262\203\237 \315\307\236\"\262\316 \203\262 \307\236\211\262\n\203\262 \317\240\210\320\321\"*\207" [idlwave-twin-name idlwave-twin-class 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] 14 (#$ . 235260)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias idlwave-xor xor nil make-obsolete "27.1"] 4)
#@291 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.
(fn A B)
(defalias 'idlwave-routine-entry-compare #[514 "@A@\3008\301!\301\3008!\232\204+ \3008\204 \302\207\211\204# \303\207\211\227\3008\227\231\207\227@\227\232\204; \227@\227\231\207A@=\204] \304=\203M \305\202N \306A@\304=\203Z \305\202[ \306W\207\307\"\207" [2 idlwave-downcase-safe nil t fun 1 0 idlwave-routine-entry-compare-twins] 9 (#$ . 236426)])
#@157 Compare two routine entries, under the assumption that they are twins.
This basically calls `idlwave-routine-twin-compare' with the correct args.
(fn A B)
(defalias 'idlwave-routine-entry-compare-twins #[514 "@\3028\3038\211@\3038\211@\304!\304!\305;\203( \306!CE\202. CE;\203> \306!CE\202D CE\"*\207" [idlwave-twin-name idlwave-twin-class 2 3 idlwave-routine-source-file idlwave-routine-twin-compare file-truename] 13 (#$ . 237092)])
#@231 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.
(fn A B)
(defalias 'idlwave-routine-twin-compare #[514 "@@A@A@\3038\3038\304>\305>\306>\306> \307=\206, \205, ? \307=\206: \205: ?\310>\310>\311 ;\205Q \312\313!\";\205^ \312\313!\">G>G;\203t \314!\227\202u \315;\203\203 \314!\227\202\204 \315\203\226 \316\317\320\227!\320 \227!#\202\235 \316\321\320 \227!\"\322\"\205\257 \211\205\257 \323\324\"\325\230\322\"\205\302 \211\205\302 \323\324\"\325\230\204\317 \262\202\327 \211?\205\325 \266\202\203\335 \207\204\352 \262\202\362 \211?\205\360 \266\202\203\370 \207\n\203
\204 \262\202\211?\205\266\202\203
\207\204$\262\202,\211?\205*\266\202\2032\207\n\n\204?\262\202G\211?\205E\266\202\203M\n\207\204X\262\202`\211?\205^\266\202\203e\207\203\210\203\210\203\210\204|\262\202\204\211?\205\202\266\202\203\210\207V\203\222\326\207\327\207" [idlwave-twin-class idlwave-twin-name idlwave-sort-prefer-buffer-info 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] 31 (#$ . 237561)])
#@15
(fn SOURCE)
(defalias 'idlwave-routine-source-file #[257 "\3008\203 \301A@\3008\"\207\211A@\207" [2 expand-file-name] 5 (#$ . 239065)])
#@57 Downcase if string, else return unchanged.
(fn STRING)
(defalias 'idlwave-downcase-safe #[257 "\211;\203 \211\227\207\207" [] 2 (#$ . 239213)])
#@42 How often is ELT in LIST?
(fn ELT LIST)
(defalias 'idlwave-count-eq #[514 "\300\301\302\303\304\"\"\"G\207" [delq nil mapcar make-closure #[257 "\211\300=\207" [V0] 3 "\n\n(fn X)"]] 8 (#$ . 239365)])
#@50 How often is ELT a key in ALIST?
(fn ELT ALIST)
(defalias 'idlwave-count-memq #[514 "\300\301\302\303\304\"\"\"G\207" [delq nil mapcar make-closure #[257 "\211@\300=\207" [V0] 3 "\n\n(fn X)"]] 8 (#$ . 239575)])
#@54 Non-nil if FILE is in the system library.
(fn FILE)
(defalias 'idlwave-syslib-p #[257 "\300\301\302\303\304 \"!!\301!\305\306\307!P\"\207" [file-name-as-directory file-truename expand-file-name "lib" idlwave-sys-dir string-match "^" regexp-quote] 7 (#$ . 239796)])
#@47 Non-nil if FILE is in the library.
(fn FILE)
(defalias 'idlwave-lib-p #[257 "\300\301!!\302\303 \"\207" [file-name-directory file-truename assoc idlwave-true-path-alist] 5 (#$ . 240071)])
#@70 Add a flag to the path list entry, if not set.
(fn LIST-ENTRY FLAG)
(defalias 'idlwave-path-alist-add-flag #[514 "\211A\235\203
\211\202 B\262\241\207" [] 6 (#$ . 240268)])
#@69 Remove a flag to the path list entry, if set.
(fn LIST-ENTRY FLAG)
(defalias 'idlwave-path-alist-remove-flag #[514 "\300A\"\241\207" [delq] 5 (#$ . 240456)])
#@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 #[0 "\206\n \302\303 \"\211\207" [idlwave-true-path-alist idlwave-path-alist mapcar #[257 "\300\301\302@!!!AB\207" [file-name-as-directory file-truename directory-file-name] 5 "\n\n(fn X)"]] 3 (#$ . 240626)])
#@59 Non-nil if the system lib file !DIR/lib has been scanned.
(defalias 'idlwave-syslib-scanned-p #[0 "\300\301\302\303\304 \"!!\305\306 \"A\207" [file-name-as-directory file-truename expand-file-name "lib" idlwave-sys-dir assoc idlwave-true-path-alist] 5 (#$ . 241060)])
#@97 Search for the previous procedure or function.
Return nil if not found. For use with imenu.el.
(defalias 'idlwave-prev-index-position #[0 "\300 \301\302\"\216\303\304\305\306#)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] idlwave-find-key "\\<\\(pro\\|function\\)\\>" -1 nomark] 5 (#$ . 241335)])
#@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 #[0 "\300\301!\210\300\302!\210`\303\304!\210\305`\"\207" [forward-sexp 2 -1 re-search-forward "[a-zA-Z_][a-zA-Z0-9$_]+\\(::[a-zA-Z_][a-zA-Z0-9$_]+\\)?" buffer-substring-no-properties] 4 (#$ . 241684)])
(byte-code "\300\301\3021 \303\304!\210\3050\202 \210\3061 \303\307!\210\3070\202 \210\310\"\207" [defalias idlwave-function-menu (error) require func-menu function-menu (error) imenu nil] 4)
#@55 Edit the current file in IDL Development environment.
(defalias 'idlwave-edit-in-idlde #[0 "\301\302\303\304\305\306 &\207" [idlwave-shell-explicit-file-name start-process "idldeclient" nil "-c" "-e" buffer-file-name] 7 (#$ . 242235) nil])
#@32 Start the IDLhelp application.
(defalias 'idlwave-launch-idlhelp #[0 "\203 \302 \207\303\304\305 #\207" [idlwave-help-use-assistant idlwave-help-application idlwave-help-assistant-raise start-process "idlhelp" nil] 4 (#$ . 242483) 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" auto-fill-mode :style toggle :selected auto-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 t]) ("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)]))
#@31 IDL and WAVE CL editing menu.
(defvar idlwave-mode-menu nil (#$ . 246469))
(easy-menu-do-define 'idlwave-mode-menu idlwave-mode-map "IDL and WAVE CL editing menu." idlwave-mode-menu-def)
#@31 IDL and WAVE CL editing menu.
(defvar idlwave-mode-debug-menu nil (#$ . 246662))
(easy-menu-do-define 'idlwave-mode-debug-menu idlwave-mode-map "IDL and WAVE CL editing menu." idlwave-mode-debug-menu-def)
#@57 Call the customize function with `idlwave' as argument.
(defalias 'idlwave-customize #[0 "\300\301!\204 \302\303\304\"\210\305\306!\207" [featurep idlw-shell load "idlw-shell" t customize-browse idlwave] 3 (#$ . 246873) nil])
#@72 Create a full customization menu for IDLWAVE, insert it into the menu.
(defalias 'idlwave-create-customize-menu #[0 "\300\301!\204 \302\303\304\"\210\305\306\307\310\311\312\313!\314BBB#\210\315\316!\207" [featurep idlw-shell load "idlw-shell" t easy-menu-change ("IDLWAVE") "Customize" ["Browse IDLWAVE group" idlwave-customize t] "--" customize-menu-create idlwave (["Set" Custom-set t] ["Save" Custom-save t] ["Reset to Current" Custom-reset-current t] ["Reset to Saved" Custom-reset-saved t] ["Reset to Standard Settings" Custom-reset-standard t]) message "\"IDLWAVE\"-menu now contains full customization menu"] 7 (#$ . 247106) nil])
#@66 Use the finder to view the file documentation from `idlwave.el'.
(defalias 'idlwave-show-commentary #[0 "\300\301!\207" [finder-commentary "idlwave.el"] 2 (#$ . 247752) nil])
#@69 Use the finder to view the file documentation from `idlw-shell.el'.
(defalias 'idlwave-shell-show-commentary #[0 "\300\301!\207" [finder-commentary "idlw-shell.el"] 2 (#$ . 247933) nil])
#@52 Read documentation for IDLWAVE in the info system.
(defalias 'idlwave-info #[0 "\300\301!\207" [info "idlwave"] 2 (#$ . 248126) nil])
#@562 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.
(fn ARG)
(defalias 'idlwave-list-abbrevs #[257 "\306C\306C\306C\306C\306\307C\307C\310\311\312 \n\n\n\n & \"\210\313\242\314\"\240\210\315\316\242\242#\262 r\317\320!q\210p\321 \210\306\211\322\211\322 &\323 \210\324\325!\210+\211 '\n\203 \326\327!\210\326\330!\210\326\315\331\332\333$!\210\326\315\334\335\336$!\210\202\233 \326\337!\210\326\340!\210\326\315\331\341\342$!\210\326\315\334\343\342$!\210\242\211\203\317 \211@ @\240\210A@\240\210\3448\240\210\326\315\f\242\f\242\f\242$!\210A\266\202\202\236 \210\345!\210)\266\nr\320q\210\322\211()\207" [idlwave-mode-abbrev-table default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks nil 0 mapatoms make-closure #[257 "\211J\205p \302\307!\240\210\303J\240\210\304K\240\210\300\203# \304\310\304\242!\240\210\202E \304\242<\203A \311\304\2428;\203A \303\312\311\304\2428P\240\210\304\313\240\210\202E \304\313\240\210\300\204R \303\242\302\242\230?\205p \305\211\242\302\242G]\240\210\306\211\242\303\242G]\240\210\301\302\242\303\242\304\242E\301\242B\240\207" [V0 V1 V2 V3 V4 V5 V6 symbol-name prin1-to-string 2 "EVAL: " #1=""] 5 "\n\n(fn SYM)"] sort #[514 "@@\231\207" [] 4 "\n\n(fn A B)"] 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 inhibit-read-only standard-output truncate-lines] 20 (#$ . 248267) "P"])
(byte-code "\301\302\303\"\210\204\f \304 \210\305\306!\210\307\310\311\312#\210\313\310\311\314#\210\315\316!\207" [idlwave-routines eval-after-load "speedbar" #[0 "\300\301!\207" [speedbar-add-supported-extension ".pro"] 2] idlwave-start-load-rinfo-timer run-hooks idlwave-load-hook defalias idlwave-uniquify seq-uniq nil make-obsolete "28.1" provide idlwave] 4)