| blob | 8f2cb37998614bfc07290b7baa153b8ab83e4a2c |
1 ;;; idlwave.el --- IDL and WAVE CL editing mode for GNU Emacs
2 ;; Copyright (c) 1994-1997 Chris Chase
3 ;; Copyright (c) 1999 Carsten Dominik
4 ;; Copyright (c) 1999 Free Software Foundation
6 ;; Author: Chris Chase <chase@att.com>
7 ;; Maintainer: Carsten Dominik <dominik@strw.leidenuniv.nl>
8 ;; Version: 3.15
9 ;; Date: $Date: 2000/02/04 09:19:36 $
10 ;; Keywords: languages
12 ;; This file is part of the GNU Emacs.
14 ;; GNU Emacs is free software; you can redistribute it and/or modify
15 ;; it under the terms of the GNU General Public License as published by
16 ;; the Free Software Foundation; either version 2, or (at your option)
17 ;; any later version.
19 ;; GNU Emacs is distributed in the hope that it will be useful,
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 ;; GNU General Public License for more details.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs; see the file COPYING. If not, write to the
26 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
27 ;; Boston, MA 02111-1307, USA.
29 ;;; Commentary:
31 ;; In distant past, based on pascal.el. Though bears little
32 ;; resemblance to that now.
33 ;;
34 ;; Incorporates many ideas, such as abbrevs, action routines, and
35 ;; continuation line indenting, from wave.el.
36 ;; wave.el original written by Lubos Pochman, Precision Visuals, Boulder.
37 ;;
38 ;; See the mode description ("C-h m" in idlwave-mode or "C-h f idlwave-mode")
39 ;; for features, key bindings, and info.
40 ;; Also, Info format documentation is available with `M-x idlwave-info'
41 ;;
42 ;;
43 ;; INSTALLATION
44 ;; ============
45 ;;
46 ;; Follow the instructions in the INSTALL file of the distribution.
47 ;; In short, put this file on your load path and add the following
48 ;; lines to your .emacs file:
49 ;;
50 ;; (autoload 'idlwave-mode "idlwave" "IDLWAVE Mode" t)
51 ;; (autoload 'idlwave-shell "idlw-shell" "IDLWAVE Shell" t)
52 ;; (setq auto-mode-alist (cons '("\\.pro\\'" . idlwave-mode) auto-mode-alist))
53 ;;
54 ;;
55 ;; SOURCE
56 ;; ======
57 ;;
58 ;; The newest version of this file is available from the maintainers
59 ;; Webpage.
60 ;;
61 ;; http://www.strw.leidenuniv.el/~dominik/Tools/idlwave
62 ;;
63 ;; DOCUMENTATION
64 ;; =============
65 ;;
66 ;; IDLWAVE is documented online in info format.
67 ;; A printable version of the documentation is available from the
68 ;; maintainers webpage (see under SOURCE)
69 ;;
70 ;;
71 ;; ACKNOWLEDGMENTS
72 ;; ===============
73 ;;
74 ;; Thanks to the following people for their contributions and comments:
75 ;;
76 ;; Ulrik Dickow <dickow@nbi.dk>
77 ;; Eric E. Dors <edors@lanl.gov>
78 ;; Stein Vidar H. Haugan <s.v.h.haugan@astro.uio.no>
79 ;; David Huenemoerder <dph@space.mit.edu>
80 ;; Kevin Ivory <Kevin.Ivory@linmpi.mpg.de>
81 ;; Xuyong Liu <liu@stsci.edu>
82 ;; Simon Marshall <Simon.Marshall@esrin.esa.it>
83 ;; Laurent Mugnier <mugnier@onera.fr>
84 ;; Lubos Pochman <lubos@rsinc.com>
85 ;; Patrick M. Ryan <pat@jaameri.gsfc.nasa.gov>
86 ;; Marty Ryba <ryba@ll.mit.edu>
87 ;; Phil Williams <williams@irc.chmcc.org>
88 ;; J.D. Smith <jdsmith@astrosun.tn.cornell.edu>
89 ;; Phil Sterne <sterne@dublin.llnl.gov>
90 ;;
91 ;; CUSTOMIZATION:
92 ;; =============
93 ;;
94 ;; IDLWAVE has customize support - so if you want to learn about the
95 ;; variables which control the behavior of the mode, use
96 ;; `M-x idlwave-customize'.
97 ;;
98 ;; You can set your own preferred values with Customize, or with Lisp
99 ;; code in .emacs. For an example of what to put into .emacs, check
100 ;; the TexInfo documentation.
101 ;;
102 ;; KNOWN PROBLEMS:
103 ;; ==============
104 ;;
105 ;; Moving the point backwards in conjunction with abbrev expansion
106 ;; does not work as I would like it, but this is a problem with
107 ;; emacs abbrev expansion done by the self-insert-command. It ends
108 ;; up inserting the character that expanded the abbrev after moving
109 ;; point backward, e.g., "\cl" expanded with a space becomes
110 ;; "LONG( )" with point before the close paren. This is solved by
111 ;; using a temporary function in `post-command-hook' - not pretty,
112 ;; but it works.
113 ;;
114 ;; Tabs and spaces are treated equally as whitespace when filling a
115 ;; comment paragraph. To accomplish this, tabs are permanently
116 ;; replaced by spaces in the text surrounding the paragraph, which
117 ;; may be an undesirable side-effect. Replacing tabs with spaces is
118 ;; limited to comments only and occurs only when a comment
119 ;; paragraph is filled via `idlwave-fill-paragraph'.
120 ;;
121 ;; "&" is ignored when parsing statements.
122 ;; Avoid muti-statement lines (using "&") on block begin and end
123 ;; lines. Multi-statement lines can mess up the formatting, for
124 ;; example, multiple end statements on a line: endif & endif.
125 ;; Using "&" outside of block begin/end lines should be okay.
126 ;;
127 ;; It is possible that the parser which decides what to complete has
128 ;; problems with pointer dereferencing statements. I don't use
129 ;; pointers often enough to find out - please report any problems.
130 ;;
131 ;; Completion and Routine Info do not know about inheritance. Thus,
132 ;; Keywords inherited from superclasses are not displayed and cannot
133 ;; completed.
134 ;;
135 ;; When forcing completion of method keywords, the initial
136 ;; query for a method has multiple entries for some methods. Would
137 ;; be too difficult to fix this hardly used case.
138 ;;
139 \f
140 ;;; Code:
145 ;; Kludge to allow `defcustom' for Emacs 19.
148 nil ;; We've got what we needed
149 ;; We have the old or no custom-library, hack around it!
155 "Major mode for editing IDL/WAVE CL .pro files"
166 ;;; Variables for indentation behavior ---------------------------------------
169 "Indentation and formatting options for IDLWAVE mode."
173 "*Extra indentation for the main block of code.
174 That is the block between the FUNCTION/PRO statement and the END
175 statement for that program unit."
180 "*Extra indentation applied to block lines.
181 If you change this, you probably also want to change `idlwave-end-offset'."
186 "*Extra indentation applied to block END lines.
187 A value equal to negative `idlwave-block-indent' will make END lines
188 line up with the block BEGIN lines."
193 "*Extra indentation applied to continuation lines.
194 This extra offset applies to the first of a set of continuation lines.
195 The following lines receive the same indentation as the first.
196 Also, the value of this variable applies to continuation lines inside
197 parenthesis. When the current line contains an open unmatched ([{,
198 the next line is indented to that parenthesis plus the value of this variable."
203 "*If set non-nil then comment paragraphs are indented under the
204 hanging indent given by `idlwave-hang-indent-regexp' match in the first line
205 of the paragraph."
210 "*Regular expression matching the position of the hanging indent
211 in the first line of a comment paragraph. The size of the indent
212 extends to the end of the match for the regular expression."
217 "*If non-nil then use last match on line for `idlwave-indent-regexp'."
222 "*If non-nil then auto fill will only operate on comment lines."
227 "*If non-nil then auto fill will split strings with the IDL `+' operator.
228 When the line end falls within a string, string concatenation with the
229 '+' operator will be used to distribute a long string over lines.
230 If nil and a string is split then a terminal beep and warning are issued.
232 This variable is ignored when `idlwave-fill-comment-line-only' is
233 non-nil, since in this case code is not auto-filled."
238 "*If non-nil then `idlwave-split-line' will split strings with `+'.
239 When the splitting point of a line falls inside a string, split the string
240 using the `+' string concatenation operator. If nil and a string is
241 split then a terminal beep and warning are issued."
246 "*The indentation of a comment that starts with this regular
247 expression will not be changed. Note that the indentation of a comment
248 at the beginning of a line is never changed."
253 "*A comment anchored at the beginning of line.
254 A comment matching this regular expression will not have its
263 "*A comment that starts with this regular expression on a line by
264 itself is indented as if it is a part of IDL code. As a result if
265 the comment is not preceded by whitespace it is unchanged."
269 ;; Comments not matching any of the above will be indented as a
270 ;; right-margin comment, i.e., to a minimum of `comment-column'.
273 ;;; Routine Info and Completion ---------------------------------------
276 "Routine info and name/keyword completion options for IDLWAVE mode."
280 "*Non-nil means, scan all buffers for IDL programs when updating info.
281 `idlwave-update-routine-info' scans buffers of the current Emacs session
282 for routine definitions. When this variable is nil, it only parses the
283 current buffer. When non-nil, all buffers are searched.
285 variable for the duration of the command."
290 "*Non-nil means query the shell for info about compiled routines.
291 Querying the shell is useful to get information about compiled modules,
292 and it is turned on by default. However, when you have a complete library
293 scan, this is not necessary."
298 "Library path for Windows and MacOS. Not needed under Unix.
299 When selecting the directories to scan for IDL library routine info,
300 IDLWAVE can under UNIX query the shell for the exact search path.
301 However, under Windows and MacOS, the IDLWAVE shell does not work. In this
302 case, this variable specifies the path where IDLWAVE can find library files.
303 The shell will only be asked when this variable is nil.
304 The value is a list of directories. A directory preceeded by a `+' will
305 be searched recursively. If you set this variable on a UNIX system, the shell
306 will not be asked."
311 "*File for routine information of the IDL library.
312 When this points to a file, the file will be loaded when IDLWAVE first
313 accesses routine info (or does completion).
314 When you scan the library with `idlwave-create-libinfo-file', this file
315 will be used to store the result."
333 "Association list setting the case of completed words.
335 This variable determines the case (UPPER/lower/Capitalized...) of
336 words inserted into the buffer by completion. The preferred case can
337 be specified separately for routine names, keywords, classes and
338 methods.
339 This alist should therefore have entries for `routine' (normal
340 functions and procedures, i.e. non-methods), `keyword', `class', and
341 `method'. Plausible values are
343 upcase upcase whole word, like `BOX_CURSOR'
344 downcase downcase whole word, like `read_ppm'
345 capitalize capitalize each part, like `Widget_Control'
346 preserve preserve case as is, like `IDLgrView'
348 The value can also be any Emacs Lisp function which transforms the
349 case of characters in a string.
351 A value of `preserve' means that the case of the completed word is
352 identical to the way it was written in the definition statement of the
353 routine. This was implemented to allow for mixed-case completion, in
354 particular of object classes and methods.
355 If a completable word is defined in multiple locations, the meaning of
356 `preserve' is not unique since the different definitions might be
357 cased differently. Therefore IDLWAVE always takes the case of the
358 *first* definition it encounters during routine info collection and
359 uses the case derived from it consistently.
361 Note that a lowercase-only string in the buffer will always be completed in
362 lower case (but see the variable `idlwave-completion-force-default-case').
364 After changing this variable, you need to either restart Emacs or press
365 `C-u C-c C-i' to update the internal lists."
372 "*Non-nil means, completion will always honor `idlwave-completion-case'.
373 When nil, only the completion of a mixed case or upper case string
374 will honor the default settings in `idlwave-completion-case', while
375 the completion of lower case strings will be completed entirely in
376 lower case."
381 "*Non-nil means, the empty string is considered downcase for completion.
382 The case of what is already in the buffer determines the case of completions.
383 When this variable is non-nil, the empty string is considered to be downcase.
384 Completing on the empty string then offers downcase versions of the possible
385 completions."
390 "Obsolete variable. See `idlwave-complete-empty-string-as-lower-case' and
394 "*Non-nil means, the case of tokens in buffers dominates over system stuff.
395 To make this possible, we need to re-case everything each time we update
396 the routine info from the buffers. This is slow.
397 The default is to consider the case given in the system and library files
398 first which makes updating much faster."
403 "*Number of classes to show when completing object methods and keywords.
404 When completing methods or keywords for an object with unknown class,
405 the *Completions* buffer will show the legal classes for each completion
406 like this:
408 MyMethod <Class1,Class2,Class3>
410 The value of this variable may be nil to inhibit display, or an integer to
411 indicate the maximum number of classes to display.
413 On XEmacs, a full list of classes will also be placed into a `help-echo'
414 property on the competion items, so that the list of classes for the current
415 item is displayed in the echo area. If the value of this variable is a
416 negative integer, the `help-echo' property will be suppressed."
422 "*Non-nil means, fontify the classes in completions buffer.
423 This makes it easier to distinguish the completion items from the extra
424 class info listed. See `idlwave-completion-show-classes'."
430 "Association list governing specification of object classes for completion.
432 When IDLWAVE is trying to complete items which belong to the object
433 oriented part of IDL, it usually cannot determine the class of a given
434 object from context. In order to provide the user with a correct list
435 of methods or keywords, it would have to determine the appropriate
436 class. IDLWAVE has two ways to deal with this problem.
438 1. One possibility is to combine the items of all available
439 classes for the purpose of completion. So when completing a
440 method, all methods of all classes are available, and when
441 completing a keyword, all keywords allowed for this method in any
442 class will be possible completions. This behavior is very much
443 like normal completion and is therefore the default. It works much
444 better than one might think - only for the INIT, GETPROPERTY and
445 SETPROPERTY the keyword lists become uncomfortably long.
446 See also `idlwave-completion-show-classes'.
448 2. The second possibility is to ask the user on each occasion. To
449 make this less interruptive, IDLWAVE can store the class as a text
450 property on the object operator `->'. For a given object in the
451 source code, class selection will then be needed only once
452 - for example to complete the method. Keywords to the method can
453 then be completed directly, because the class is already known.
454 You will have to turn on the storage of the selected class
455 explicitly with the variable `idlwave-store-inquired-class'.
457 This variable allows to configure IDLWAVE's behavior during
458 completion. Its value is an alist, which should contain at least two
459 elements: (method-default . VALUE) and (keyword-default . VALUE),
460 where VALUE is either t or nil. These specify if the class should be
461 determined during method and keyword completion, respectively.
463 The alist may have additional entries specifying exceptions from the
464 keyword completion rule for specific methods, like INIT or
465 GETPROPERTY. In order to turn on class specification for the INIT
475 :inline t
480 "*Non-nil means, store class of a method call as text property on `->'.
481 IDLWAVE sometimes has to ask the user for the class associated with a
482 particular object method call. This happens during the commands
483 `idlwave-routine-info' and `idlwave-complete', depending upon the
484 value of the variable `idlwave-query-class'.
486 When you specify a class, this information can be stored as a text
487 property on the `->' arrow in the source code, so that during the same
488 editing session, IDLWAVE will not have to ask again. When this
489 variable is non-nil, IDLWAVE will store and reuse the class information.
491 on the arrow.
493 The default of this variable is nil, since the result of commands then
494 is more predictable. However, if you know what you are doing, it can
495 be nice to turn this on.
497 An arrow which knows the class will be highlighted with
499 displays (with prefix arg: deletes) the class stored on the arrow
500 at point."
505 "*Face to highlight object operator arrows `->' which carry a class property.
506 When IDLWAVE stores a class name as text property on an object arrow
507 (see variable `idlwave-store-inquired-class', it highlights the arrow
508 with this font in order to remind the user that this arrow is special."
513 "*Non-nil means, resize the Routine-info *Help* window to fit the content."
518 "*Non-nil means, completion automatically adds `=' after completed keywords."
523 "*Non-nil means, completion automatically adds `(' after completed function.
524 Nil means, don't add anything.
525 A value of `2' means, also add the closing parenthesis and position cursor
526 between the two."
533 "*Non-nil means, try to restore the window configuration after completion.
534 When completion is not unique, Emacs displays a list of completions.
535 This messes up your window configuration. With this variable set, IDLWAVE
536 restores the old configuration after successful completion."
540 ;;; Variables for abbrev and action behavior -----------------------------
543 "IDLWAVE performs actions when expanding abbreviations or indenting lines.
544 The variables in this group govern this."
548 "*Non-nil means performs actions when indenting.
549 The actions that can be performed are listed in `idlwave-indent-action-table'."
554 "*A single character string used to start abbreviations in abbrev mode.
555 Possible characters to chose from: ~`\%
556 or even '?'. '.' is not a good choice because it can make structure
557 field names act like abbrevs in certain circumstances.
559 Changes to this in `idlwave-mode-hook' will have no effect. Instead a user
560 must set it directly using `setq' in the .emacs file before idlwave.el
561 is loaded."
566 "*Non-nil means, enable `idlwave-surround'.
567 If non-nil, `=',`<',`>',`&',`,', `->' are surrounded with spaces by
568 `idlwave-surround'.
569 See help for `idlwave-indent-action-table' for symbols using `idlwave-surround'.
571 Also see the default key bindings for keys using `idlwave-surround'.
572 Keys are bound and made into actions calling `idlwave-surround' with
573 `idlwave-action-and-binding'.
574 See help for `idlwave-action-and-binding' for examples.
576 Also see help for `idlwave-surround'."
581 "*Non-nil means pad '=' for keywords like assignments.
582 Whenever `idlwave-surround' is non-nil then this affects how '=' is padded
583 for keywords. If non-nil it is padded the same as for assignments.
584 If nil then spaces are removed."
589 "*Non-nil means point blinks to block beginning for `idlwave-show-begin'."
594 "*Non-nil means expand generic END to ENDIF/ENDELSE/ENDWHILE etc."
599 "*Non-nil means the abbrev hook can move point.
600 Set to nil by `idlwave-expand-region-abbrevs'. To see the abbrev
601 definitions, use the command `list-abbrevs', for abbrevs that move
602 point. Moving point is useful, for example, to place point between
603 parentheses of expanded functions.
605 See `idlwave-check-abbrev'."
610 "*Non-nil means all abbrevs will be forced to either upper or lower case.
611 If the value t, all expanded abbrevs will be upper case.
612 If the value is 'down then abbrevs will be forced to lower case.
613 If nil, the case will not change.
614 If `idlwave-reserved-word-upcase' is non-nil, reserved words will always be
615 upper case, regardless of this variable."
620 "*Non-nil means, reserved words will be made upper case via abbrev expansion.
621 If nil case of reserved words is controlled by `idlwave-abbrev-change-case'.
622 Has effect only if in abbrev-mode."
626 ;;; Action/Expand Tables.
627 ;;
628 ;; The average user may have difficulty modifying this directly. It
629 ;; can be modified/set in idlwave-mode-hook, but it is easier to use
630 ;; idlwave-action-and-binding. See help for idlwave-action-and-binding for
631 ;; examples of how to add an action.
632 ;;
633 ;; The action table is used by `idlwave-indent-line' whereas both the
634 ;; action and expand tables are used by `idlwave-indent-and-action'. In
635 ;; general, the expand table is only used when a line is explicitly
636 ;; indented. Whereas, in addition to being used when the expand table
637 ;; is used, the action table is used when a line is indirectly
638 ;; indented via line splitting, auto-filling or a new line creation.
639 ;;
640 ;; Example actions:
641 ;;
642 ;; Capitalize system vars
643 ;; (idlwave-action-and-binding idlwave-sysvar '(capitalize-word 1) t)
644 ;;
645 ;; Capitalize procedure name
646 ;; (idlwave-action-and-binding "\\<\\(pro\\|function\\)\\>[ \t]*\\<"
647 ;; '(capitalize-word 1) t)
648 ;;
649 ;; Capitalize common block name
650 ;; (idlwave-action-and-binding "\\<common\\>[ \t]+\\<"
651 ;; '(capitalize-word 1) t)
652 ;; Capitalize label
653 ;; (idlwave-action-and-binding (concat "^[ \t]*" idlwave-label)
654 ;; '(capitalize-word -1) t)
657 "*Associated array containing action lists of search string (car),
658 and function as a cdr. This table is used by `idlwave-indent-line'.
659 See documentation for `idlwave-do-action' for a complete description of
660 the action lists.
662 Additions to the table are made with `idlwave-action-and-binding' when a
663 binding is not requested.
667 "*Associated array containing action lists of search string (car),
668 and function as a cdr. The table is used by the
669 `idlwave-indent-and-action' function. See documentation for
670 `idlwave-do-action' for a complete description of the action lists.
672 Additions to the table are made with `idlwave-action-and-binding' when a
673 binding is requested.
676 ;;; Documentation header and history keyword ---------------------------------
679 "Options for documenting IDLWAVE files."
682 ;; FIXME: make defcustom?
685 ";+
686 ; NAME:
687 ;
688 ;
689 ;
690 ; PURPOSE:
691 ;
692 ;
693 ;
694 ; CATEGORY:
695 ;
696 ;
697 ;
698 ; CALLING SEQUENCE:
699 ;
700 ;
701 ;
702 ; INPUTS:
703 ;
704 ;
705 ;
706 ; OPTIONAL INPUTS:
707 ;
708 ;
709 ;
710 ; KEYWORD PARAMETERS:
711 ;
712 ;
713 ;
714 ; OUTPUTS:
715 ;
716 ;
717 ;
718 ; OPTIONAL OUTPUTS:
719 ;
720 ;
721 ;
722 ; COMMON BLOCKS:
723 ;
724 ;
725 ;
726 ; SIDE EFFECTS:
727 ;
728 ;
729 ;
730 ; RESTRICTIONS:
731 ;
732 ;
733 ;
734 ; PROCEDURE:
735 ;
736 ;
737 ;
738 ; EXAMPLE:
739 ;
740 ;
741 ;
742 ; MODIFICATION HISTORY:
743 ;
744 ;-
746 "*A list (PATHNAME STRING) specifying the doc-header template to use for
747 summarizing a file. If PATHNAME is non-nil then this file will be included.
748 Otherwise STRING is used. If NIL, the file summary will be omitted.
749 For example you might set PATHNAME to the path for the
753 "*The hook function used to update the timestamp of a function."
758 "*The modifications keyword to use with the log documentation commands.
759 A ':' is added to the keyword end.
760 Inserted by doc-header and used to position logs by doc-modification.
761 If nil it will not be inserted."
766 "*Regexp matching the start of a document library header."
771 "*Regexp matching the end of a document library header."
775 ;;; External Programs -------------------------------------------------------
778 "Miscellaneous options for IDLWAVE mode."
781 ;; WARNING: The following variable has recently been moved from
782 ;; idlw-shell.el to this file. I hope this does not break
783 ;; anything.
786 "*If non-nil, is the command to run IDL.
787 Should be an absolute file path or path relative to the current environment
788 execution search path."
792 ;; FIXME: Document a case when is this needed.
794 "*A list of command line options for calling the IDL program."
799 "*The external application providing reference help for programming."
803 ;;; Miscellaneous variables -------------------------------------------------
806 "Miscellaneous options for IDLWAVE mode."
810 "*Non-nil displays a startup message when `idlwave-mode' is first called."
816 common-blocks class-arrows)
817 "Items which should be fontified on the default fontification level 2.
818 IDLWAVE defines 3 levels of fontification. Level 1 is very little, level 3
819 is everything and level 2 is specified by this list.
820 This variable must be set before IDLWAVE gets loaded. It is
821 a list of symbols, the following symbols are allowed.
823 pros-and-functions Procedure and Function definitions
824 batch-files Batch Files
825 idl-keywords IDL Keywords
826 label Statement Labels
827 goto Goto Statements
828 common-blocks Common Blocks
829 keyword-parameters Keyword Parameters in routine definitions and calls
830 system-variables System Variables
831 fixme FIXME: Warning in comments (on XEmacs only v. 21.0 and up)
832 class-arrows Object Arrows with class property"
848 "Normal hook. Executed when a buffer is put into `idlwave-mode'."
853 "Normal hook. Executed when idlwave.el is loaded."
857 ;;;
858 ;;; End customization variables section
859 ;;;
861 ;;; Non customization variables
863 ;;; font-lock mode - Additions by Phil Williams, Ulrik Dickow and
864 ;;; Simon Marshall <simon@gnu.ai.mit.edu>
865 ;;; and Carsten Dominik...
881 ;; The following are the reserved words in IDL. Maybe we should
882 ;; highlight some more stuff as well?
884 ;; To update this regexp, update the list of keywords and
885 ;; evaluate the form.
886 ; (insert
887 ; (concat
888 ; "\"\\\\<"
889 ; (regexp-opt
890 ; '("and" "or" "xor" "not"
891 ; "eq" "ge" "gt" "le" "lt" "ne"
892 ; "for" "do" "endfor"
893 ; "if" "then" "endif" "else" "endelse"
894 ; "case" "of" "endcase"
895 ; "begin" "end"
896 ; "repeat" "until" "endrep"
897 ; "while" "endwhile"
898 ; "goto" "return"
899 ; "inherits" "mod"
900 ; "on_error" "on_ioerror")) ; on_error is not officially reserved
901 ; "\\\\>\""))
910 ;; Procedure declarations. Fontify keyword plus procedure name.
911 ;; Function declarations. Fontify keyword plus function name.
917 ;; Common blocks
923 ;; Start with point after block name and comma
925 nil
927 )))
929 ;; Batch files
933 ;; FIXME warning.
937 ;; Labels
941 ;; The goto statement and its label
947 ;; Named parameters, like /xlog or ,xrange=[]
948 ;; This is anchored to the comma preceeding the keyword.
949 ;; Treats continuation lines, works only during whole buffer
950 ;; fontification. Slow, use it only in fancy fontification.
952 '("[(,][ \t]*\\(\\$[ \t]*\\(;.*\\)?\\(\n[ \t]*;.*\\)*\n[ \t]*\\)?\\(/[a-zA-Z_]\\sw*\\|[a-zA-Z_]\\sw*[ \t]*=\\)"
955 ;; System variables start with a bang.
960 ;; Special and unusual operators (not used because too noisy)
964 ;; All operators (not used because too noisy)
968 ;; Arrows with text property `idlwave-class'
972 idlwave-class-arrow-face
975 )
977 ;; The following lines are just a dummy to make the compiler shut up
978 ;; about variables bound but not used.
980 idl-keywords idl-keywords
981 pros-and-functions pros-and-functions
982 common-blocks common-blocks
983 batch-files batch-files
984 fixme fixme
985 label label
986 goto goto
987 keyword-parameters keyword-parameters
988 system-variables system-variables
989 special-operators special-operators
990 all-operators all-operators
991 class-arrows class-arrows)
995 batch-files
996 ))
1003 batch-files
1004 idl-keywords
1005 label goto
1006 common-blocks
1007 keyword-parameters
1008 system-variables
1009 class-arrows
1010 ))
1011 )
1014 ;; Match an object arrow with class property
1024 idlwave-font-lock-keywords-1
1025 idlwave-font-lock-keywords-2
1026 idlwave-font-lock-keywords-3)
1027 nil t
1029 beginning-of-line))
1035 "Regexp to match the start of a full-line comment.
1036 That is the _beginning_ of a line containing a comment delimiter `;' preceded
1040 "Regular expression to find the beginning of a block. The case does
1044 "Regular expression to find the beginning of a unit. The case does
1048 "Regular expression to find the line that indicates the end of unit.
1049 This line is the end of buffer or the start of another unit. The case does
1057 "Regular expression to find the end of a block. The case does
1069 "Matches between statements and the corresponding END variant.
1070 The cars are the reserved words starting a block. If the block really
1071 begins with BEGIN, the cars are the reserved words before the begin
1072 which can be used to identify the block type.
1073 This is used to check for the correct END type, to close blocks and
1078 "Regular expression matching reserved words which can stand before
1079 blocks starting with a BEGIN statement. The matches must have associations
1096 ;; "endif else" is the the only possible "end" that can be
1097 ;; followed by a statement on the same line.
1099 ;; all other "end"s can not be followed by a statement.
1112 "Associated list of statement matching regular expressions.
1113 Each regular expression matches the start of an IDL statement. The
1114 first element of each association is a symbol giving the statement
1115 type. The associated value is a list. The first element of this list
1116 is a regular expression matching the start of an IDL statement for
1117 identifying the statement type. The second element of this list is a
1118 regular expression for finding a substatement for the type. The
1119 substatement starts after the end of the found match modulo
1120 whitespace. If it is nil then the statement has no substatement. The
1121 list order matters since matching an assignment statement exactly is
1122 not possible without parsing. Thus assignment statement become just
1131 ;; Note that this is documented in the v18 manuals as being a string
1132 ;; of length one rather than a single character.
1133 ;; The code in this file accepts either format for compatibility.
1135 "Character to be inserted for IDL comment indentation.
1139 "Character which is inserted as a last character on previous line by
1145 "Creates a function for abbrev hooks to call `idlwave-check-abbrev' with args."
1149 ;; If I take the time I can replace idlwave-keyword-abbrev with
1150 ;; idlwave-code-abbrev and remove the quoted abbrev check from
1151 ;; idlwave-check-abbrev. Then, e.g, (idlwave-keyword-abbrev 0 t) becomes
1152 ;; (idlwave-code-abbrev idlwave-check-abbrev 0 t). In fact I should change
1153 ;; the name of idlwave-check-abbrev to something like idlwave-modify-abbrev.
1156 "Creates a function for abbrev hooks that ensures abbrevs are not quoted.
1157 Specifically, if the abbrev is in a comment or string it is unexpanded.
1158 Otherwise ARGS forms a list that is evaluated."
1200 "KEY and CMD are made into a key binding and an indent action.
1201 KEY is a string - same as for the `define-key' function. CMD is a
1202 function of no arguments or a list to be evaluated. CMD is bound to
1203 KEY in `idlwave-mode-map' by defining an anonymous function calling
1204 `self-insert-command' followed by CMD. If KEY contains more than one
1205 character a binding will only be set if SELECT is 'both.
1207 (KEY . CMD\ is also placed in the `idlwave-indent-expand-table',
1208 replacing any previous value for KEY. If a binding is not set then it
1209 will instead be placed in `idlwave-indent-action-table'.
1211 If the optional argument SELECT is nil then an action and binding are
1212 created. If SELECT is 'noaction, then a binding is always set and no
1213 action is created. If SELECT is 'both then an action and binding
1214 will both be created even if KEY contains more than one character.
1215 Otherwise, if SELECT is non-nil then only an action is created.
1217 Some examples:
1218 No spaces before and 1 after a comma
1220 A minimum of 1 space before and after `=' (see `idlwave-expand-equal').
1222 Capitalize system variables - action only
1223 (idlwave-action-and-binding idlwave-sysvar '(capitalize-word 1) t)"
1225 ;; Add action
1230 ;; Replace action command
1232 ;; New action
1234 ;; Make key binding for action
1243 cmd
1249 ;(define-key idlwave-mode-map "\C-c\C- " 'idlwave-hard-tab)
1267 ;; (define-key idlwave-mode-map "\r" 'idlwave-newline)
1268 ;; (define-key idlwave-mode-map "\t" 'idlwave-indent-line)
1278 ;; (define-key idlwave-mode-map "\C-c\C-f" 'idlwave-function)
1279 ;; (define-key idlwave-mode-map "\C-c\C-p" 'idlwave-procedure)
1298 ;; Set action and key bindings.
1299 ;; See description of the function `idlwave-action-and-binding'.
1300 ;; Automatically add spaces for the following characters
1306 ;; Automatically add spaces to equal sign if not keyword
1309 ;;;
1310 ;;; Abbrev Section
1311 ;;;
1312 ;;; When expanding abbrevs and the abbrev hook moves backward, an extra
1313 ;;; space is inserted (this is the space typed by the user to expanded
1314 ;;; the abbrev).
1315 ;;;
1328 ;;
1329 ;; Templates
1330 ;;
1339 ;;
1340 ;; Keywords, system functions, conversion routines
1341 ;;
1395 ;; This section is reserved words only. (From IDL user manual)
1396 ;;
1438 ;; defined later - so just make the compiler shut up
1442 ;;;###autoload
1444 "Major mode for editing IDL and WAVE CL .pro files.
1446 The main features of this mode are
1448 1. Indentation and Formatting
1449 --------------------------
1450 Like other Emacs programming modes, C-j inserts a newline and indents.
1451 TAB is used for explicit indentation of the current line.
1454 be used in the middle of a line to split the line at that point.
1455 When used inside a long constant string, the string is split at
1456 that point with the `+' concatenation operator.
1458 Comments are indented as follows:
1460 `;;;' Indentation remains unchanged.
1461 `;;' Indent like the surrounding code
1462 `;' Indent to a minimum column.
1464 The indentation of comments starting in column 0 is never changed.
1467 of the second line of the paragraph relative to the first will be
1469 When the variable `idlwave-fill-comment-line-only' is nil, code
1470 can also be auto-filled and auto-indented (not recommended).
1472 To convert pre-existing IDL code to your formatting style, mark the
1476 2. Routine Info
1477 ------------
1478 IDLWAVE displays information about the calling sequence and the accepted
1481 These commands know about system routines, all routines in idlwave-mode
1482 buffers and (when the idlwave-shell is active) about all modules
1484 information, which is also used for completion (see next item).
1486 3. Completion
1487 ----------
1489 keyword parameters. It is context sensitive and figures out what
1490 is expected at point (procedure/function/keyword). Lower case
1491 strings are completed in lower case, other strings in mixed or
1492 upper case.
1494 4. Code Templates and Abbreviations
1495 --------------------------------
1496 Many Abbreviations are predefined to expand to code fragments and templates.
1510 direct keybindings - see the list of keybindings below.
1513 current program unit (pro, function or main). Change log entries
1516 5. Automatic Case Conversion
1517 -------------------------
1518 The case of reserved words and some abbrevs is controlled by
1519 `idlwave-reserved-word-upcase' and `idlwave-abbrev-change-case'.
1521 6. Automatic END completion
1522 ------------------------
1523 If the variable `idlwave-expand-generic-end' is non-nil, each END typed
1524 will be converted to the specific version, like ENDIF, ENDFOR, etc.
1526 7. Hooks
1527 -----
1528 Loading idlwave.el runs `idlwave-load-hook'.
1529 Turning on `idlwave-mode' runs `idlwave-mode-hook'.
1531 8. Documentation and Customization
1532 -------------------------------
1534 to display (complain to your sysadmin if that does not work).
1535 For Postscript and HTML versions of the documentation, check IDLWAVE's
1536 homepage at `http://www.strw.leidenuniv.nl/~dominik/Tools/idlwave'.
1537 IDLWAVE has customize support - see the group `idlwave'.
1539 9. Keybindings
1540 -----------
1541 Here is a list of all keybindings of this mode.
1543 followed by the key sequence to see what the key sequence does.
1587 ;; Set tag table list to use IDLTAGS as file name.
1591 ;; Font-lock additions - originally Phil Williams, then Ulrik Dickow
1592 ;; Following line is for Emacs - XEmacs uses the corresponding porperty
1593 ;; on the `idlwave-mode' symbol.
1596 ;; Imenu setup
1604 ;; Make a local post-command-hook and add our hook to it
1608 ;; Run the mode hook
1611 ;;
1612 ;; Done with start up and initialization code.
1613 ;; The remaining routines are the code formatting functions.
1614 ;;
1617 "Push mark for compatibility with Emacs 18/19."
1623 "Inserts TAB in buffer in current position."
1627 ;;; This stuff is experimental
1630 "If non-nil, a list that can be evaluated using `eval'.
1631 It is evaluated in the lisp function `idlwave-command-hook' which is
1635 "Command run after every command.
1636 Evaluates a non-nil value of the *variable* `idlwave-command-hook' and
1637 sets the variable to zero afterwards."
1645 ;;; End experiment
1647 ;; It would be better to use expand.el for better abbrev handling and
1648 ;; versatility.
1651 "Reverses abbrev expansion if in comment or string.
1652 Argument ARG is the number of characters to move point
1653 backward if `idlwave-abbrev-move' is non-nil.
1654 If optional argument RESERVED is non-nil then the expansion
1655 consists of reserved words, which will be capitalized if
1656 `idlwave-reserved-word-upcase' is non-nil.
1657 Otherwise, the abbrev will be capitalized if `idlwave-abbrev-change-case'
1658 is non-nil, unless its value is \`down in which case the abbrev will be
1659 made into all lowercase.
1660 Returns non-nil if abbrev is left expanded."
1663 nil)
1675 t))
1678 "Returns t if point is inside a comment, nil otherwise."
1684 "Move to start of comment delimiter on current line.
1685 Moves to end of line if there is no comment delimiter.
1686 Ignores comment delimiters in strings.
1687 Returns point if comment found and nil otherwise."
1690 found)
1691 ;; Look for first comment delimiter not in a string
1703 "Insert quote and show matching quote if this is end of a string."
1714 ;; Not the end of a string
1718 "Ensure that the previous word was a token before `idlwave-show-begin'.
1719 An END token must be preceded by whitespace."
1728 "Finds the start of current block and blinks to it for a second.
1729 Also checks if the correct end statement has been used."
1730 ;; All end statements are reserved words
1732 end end1)
1734 idlwave-show-block)
1736 ;; Move inside current block
1749 ;; A generic end
1760 end1 end)
1776 idlwave-block-matches))
1777 ;;((re-search-backward ":[ \t]*\\=" limit t)
1778 ;; ;; seems to be a case thing
1779 ;; '("begin" . "end"))
1781 ;; Just a nromal block
1786 "Terminate the current block with the correct END statement."
1789 ;; Start new line if we are not in a new line
1796 ;; Check which end is needed and insert it.
1808 "Surround the LENGTH characters before point with blanks.
1809 LENGTH defaults to 1.
1810 Optional arguments BEFORE and AFTER affect the behavior before and
1811 after the characters (see also description of `idlwave-make-space'):
1813 nil do nothing
1814 0 force no spaces
1815 integer > 0 force exactly n spaces
1816 integer < 0 at least |n| spaces
1818 The function does nothing if any of the following conditions is true:
1819 - `idlwave-surround-by-blank' is nil
1820 - the character before point is inside a string or comment
1821 - the char preceeding the string to be surrounded is a member of ESCAPE-CHARS.
1822 This hack is used to avoid padding of `>' when it is part of
1823 the '->' operator. In this case, ESCAPE-CHARS would be '(?-)."
1835 ;; avoid clobbering indent
1845 ;; Check to see if the line should auto wrap
1851 "Make space at point.
1852 The space affected is all the spaces and tabs around point.
1853 If n is non-nil then point is left abs(n) spaces from the beginning of
1854 the contiguous space.
1855 The amount of space at point is determined by N.
1856 If the value of N is:
1857 nil - do nothing.
1858 > 0 - exactly N spaces.
1859 < 0 - a minimum of -N spaces, i.e., do not change if there are
1860 already -N spaces.
1861 0 - no spaces (i.e. remove any existing space)."
1875 ;; n = 0, done
1876 ))))
1879 "Inserts a newline and indents the current and previous line."
1881 ;;
1882 ;; Handle unterminated single and double quotes
1883 ;; If not in a comment and in a string then insertion of a newline
1884 ;; will mean unbalanced quotes.
1885 ;;
1890 ;;
1891 ;; The current line is being split, the cursor should be at the
1892 ;; beginning of the new line skipping the leading indentation.
1893 ;;
1894 ;; The reason we insert the new line before indenting is that the
1895 ;; indenting could be confused by keywords (e.g. END) on the line
1896 ;; after the split point. This prevents us from just using
1897 ;; `indent-for-tab-command' followed by `newline-and-indent'.
1898 ;;
1904 ;;
1905 ;; Use global variable 'comment-column' to set parallel comment
1906 ;;
1907 ;; Modeled on lisp.el
1908 ;; Emacs Lisp and IDL (Wave CL) have identical comment syntax
1910 "Compute indent for the beginning of the IDL comment delimiter."
1918 ;; On line by itself, indent as code
1921 ;; after code - do not change
1925 comment-column))))
1928 "Continue line by breaking line at point and indent the lines.
1929 For a code line insert continuation marker. If the line is a line comment
1930 then the new line will contain a comment with the same indentation.
1931 Splits strings with the IDL operator `+' if `idlwave-split-line-string' is
1932 non-nil."
1936 ;; For code line add continuation.
1937 ;; Check if splitting a string.
1941 ;; Split the string.
1943 idlwave-continuation-char beg)
1945 ;; Do not split the string.
1949 ;; Not splitting a string.
1953 ;; Indent previous line
1958 ;; Reindent new line
1962 "Moves point to the beginning of the current program unit."
1967 "Moves point to the start of the next program unit."
1973 "Mark current IDL statement."
1981 "Mark containing block."
1993 "Put mark at beginning of program, point at end.
1994 The marks are pushed."
2004 "Move to beginning of enclosing block if prefix ARG >= 0.
2005 If prefix ARG < 0 then move forward to enclosing block end."
2010 "Go to the beginning of the current block."
2016 "Go to the beginning of the current block."
2022 "Move across next nested block."
2028 "Move backward across previous nested block."
2034 "Go down a block.
2035 With ARG: ARG >= 0 go forwards, ARG < 0 go backwards.
2036 Returns non-nil if successfull."
2040 ;; Backward
2048 ;; Forward
2056 status))
2059 "Put point at beginning of doc library header, mark at end.
2060 The marks are pushed."
2078 "Move to beginning of the current statement.
2079 Skips back past statement continuations.
2080 Point is placed at the beginning of the line whether or not this is an
2081 actual statement."
2093 "Moves point to beginning of the previous statement.
2094 Returns t if the current line before moving is the beginning of
2095 the first non-comment statement in the file, and nil otherwise."
2099 ;; first line in file
2100 t
2101 ;; skip blank lines, label lines, include lines and line comments
2103 ;; The current statement is the first statement until we
2104 ;; reach another statement.
2112 ;; skip continuation lines
2118 first-statement)))
2120 ;; FIXME: end-of-statement does not work correctly when comment lines
2121 ;; are inside the statement. It does work correctly for line-end
2122 ;; comments, though.
2124 "Moves point to the end of the current IDL statement.
2125 If not in a statement just moves to end of line. Returns position."
2133 "Moves point to beginning of the next IDL statement.
2134 Returns t if that statement is the last
2135 non-comment IDL statement in the file, and nil otherwise."
2139 ;; skip blank lines, label lines, include lines and line comments
2141 ;; The current statement is the last statement until
2142 ;; we reach a new statement.
2149 last-statement))
2152 "Skip label or case statement element.
2153 Returns position after label.
2154 If there is no label point is not moved and nil is returned."
2155 ;; Just look for the first non quoted colon and check to see if it
2156 ;; is inside a sexp. If is not in a sexp it must be part of a label
2157 ;; or case statement element.
2168 nil)))
2171 "Move to start of next IDL substatement after point.
2172 Uses the type of the current IDL statement to determine if the next
2173 statement is on a new line or is a subpart of the current statement.
2174 Returns point at start of substatement modulo whitespace.
2175 If optional argument is non-nil move to beginning of current
2176 substatement. "
2180 st nst last)
2184 ;; Continue looking for substatements until we are past orig
2201 "Return the type of the current IDL statement.
2202 Uses `idlwave-statement-match' to return a cons of (type . point) with
2203 point the ending position where the type was determined. Type is the
2204 association from `idlwave-statement-match', i.e. the cons cell from the
2205 list not just the type symbol. Returns nil if not an identifiable
2206 statement."
2208 ;; Skip whitespace within a statement which is spaces, tabs, continuations
2220 "Pad '=' with spaces.
2221 Two cases: Assignment statement, and keyword assignment.
2222 The case is determined using `idlwave-start-of-substatement' and
2223 `idlwave-statement-type'.
2224 The equal sign will be surrounded by BEFORE and AFTER blanks.
2225 If `idlwave-pad-keyword' is non-nil then keyword
2226 assignment is treated just like assignment statements. Otherwise,
2227 spaces are removed for keyword assignment.
2228 Limits in for loops are treated as keyword assignment.
2229 See `idlwave-surround'. "
2230 ;; Even though idlwave-surround checks `idlwave-surround-by-blank' this
2231 ;; check saves the time of finding the statement type.
2239 idlwave-pad-keyword)
2240 ;; An assignment statement
2245 "Call `idlwave-indent-line' and do expand actions."
2248 )
2251 "Indents current IDL line as code or as a comment.
2252 The actions in `idlwave-indent-action-table' are performed.
2253 If the optional argument EXPAND is non-nil then the actions in
2254 `idlwave-indent-expand-table' are performed."
2256 ;; Move point out of left margin.
2265 ;; Indentation for a line comment
2269 ;;
2270 ;; Code Line
2271 ;;
2272 ;; Before indenting, run action routines.
2273 ;;
2276 ;;
2279 ;;
2280 ;; No longer expand abbrevs on the line. The user can do this
2281 ;; manually using expand-region-abbrevs.
2282 ;;
2283 ;; Indent for code line
2284 ;;
2287 ;; a label line
2289 ;; a batch command
2291 ;; leave flush left
2292 nil
2293 ;; indent the line
2295 ;; Adjust parallel comment
2300 ;; Get rid of marker
2302 ))
2305 "Perform an action repeatedly on a line.
2306 ACTION is a list (REG . FUNC). REG is a regular expression. FUNC is
2307 either a function name to be called with `funcall' or a list to be
2308 evaluated with `eval'. The action performed by FUNC should leave point
2309 after the match for REG - otherwise an infinite loop may be entered."
2319 "Indent from point with spaces until column COL.
2320 Inserts space before markers at point."
2326 "Indent the current line to column COL.
2327 Indents such that first non-whitespace character is at column COL
2328 Inserts spaces before markers at point."
2335 "Indents program unit which contains point."
2347 "Return appropriate indentation for current line as IDL code."
2351 ;; Check for beginning of unit - main (beginning of buffer), pro, or
2352 ;; function
2355 ;; Check for continuation line
2360 ;; calculate indent based on previous and current statements
2362 ;; calculate indent based on previous statement
2367 ;; Main block
2370 idlwave-main-block-indent))
2371 ;; Begin block
2374 idlwave-block-indent))
2377 idlwave-end-offset
2378 idlwave-block-indent))
2380 ;; adjust the indentation based on the current statement
2382 ;; End block
2387 ;;
2388 ;; Parenthesses balacing/indent
2389 ;;
2392 "Calculates the IDL continuation indent column from the previous statement.
2393 Note that here previous statement means the beginning of the current
2394 statement if this statement is a continuation of the previous line.
2395 Intervening comments or comments within the previous statement can
2396 screw things up if the comments contain parentheses characters."
2403 ;;
2404 ;; If PRO or FUNCTION declaration indent after name, and first comma.
2405 ;;
2412 ;;
2413 ;; Not a PRO or FUNCTION
2414 ;;
2415 ;; Look for innermost unmatched open paren
2416 ;;
2418 ;; Found innermost open paren.
2421 ;; Line up with next word unless this is a closing paren.
2423 ;; This is a closed paren - line up under open paren.
2426 ;; Empty - just add regular indent. Take into account
2427 ;; the forward-char
2429 ;; Skip paren
2433 ;; Line up with first word
2437 ;; No unmatched open paren. Just a simple continuation.
2440 ;; Make adjustments based on current line
2442 ;; Else statement
2448 ;; Ordinary continuation
2452 "Move in direction of the optional second argument DIR to the
2453 next keyword not contained in a comment or string and occurring before
2454 optional fourth argument LIMIT. DIR defaults to forward direction. If
2455 DIR is negative the search is backwards, otherwise, it is
2456 forward. LIMIT defaults to the beginning or end of the buffer
2457 according to the direction of the search. The keyword is given by the
2458 regular expression argument KEY-REG. The search is case insensitive.
2459 Returns position if successful and nil otherwise. If found
2460 `push-mark' is executed unless the optional third argument NOMARK is
2461 non-nil. If found, the point is left at the keyword beginning."
2487 "When optional argument DIR is non-negative, move forward to end of
2488 current block using the `idlwave-begin-block-reg' and `idlwave-end-block-reg'
2489 regular expressions. When DIR is negative, move backwards to block beginning.
2490 Recursively calls itself to skip over nested blocks. DIR defaults to
2491 forward. Calls `push-mark' unless the optional argument NOMARK is
2492 non-nil. Movement is limited by the start of program units because of
2493 possibility of unbalanced blocks."
2500 idlwave-begin-block-reg
2501 idlwave-end-block-reg))
2502 found
2504 idlwave-end-block-reg))
2508 idlwave-begin-unit-reg dir t limit)
2511 idlwave-end-unit-reg dir t limit)))
2512 limit)))
2524 "Return indentation of the current statement.
2525 If in a statement, moves to beginning of statement before finding indent."
2530 "Return the column of the indentation of the current line.
2531 Skips any whitespace. Returns 0 if the end-of-line follows the whitespace."
2535 ;; if we are at the end of blank line return 0
2540 "Tests if current line is continuation line."
2550 "Searches current line from current point for the regular expression
2551 REGEXP. If optional argument CONT is non-nil, searches to the end of
2552 the current statement. If optional arg BEG is non-nil, search starts
2553 from the beginning of the current statement. Ignores matches that end
2554 in a comment or inside a string expression. Returns point if
2555 successful, nil otherwise. This function produces unexpected results
2556 if REGEXP contains quotes or a comment delimiter. The search is case
2557 insensitive. If successful leaves point after the match, otherwise,
2558 does not move point."
2562 eos
2563 found)
2576 found))
2579 "Fills paragraphs in comments.
2580 A paragraph is made up of all contiguous lines having the same comment
2581 leader (the leading whitespace before the comment delimiter and the
2582 comment delimiter). In addition, paragraphs are separated by blank
2583 line comments. The indentation is given by the hanging indent of the
2584 first line, otherwise by the minimum indentation of the lines after
2585 the first line. The indentation of the first line does not change.
2586 Does not effect code lines. Does not fill comments on the same line
2587 with code. The hanging indent is given by the end of the first match
2588 matching `idlwave-hang-indent-regexp' on the paragraph's first line . If the
2589 optional argument NOHANG is non-nil then the hanging indent is
2590 ignored."
2592 ;; check if this is a line comment
2599 pre here diff fill-prefix-reg bcl first-indent
2600 hang start end)
2601 ;; Change tabs to spaces in the surrounding paragraph.
2602 ;; The surrounding paragraph will be the largest containing block of
2603 ;; contiguous line comments. Thus, we may be changing tabs in
2604 ;; a much larger area than is needed, but this is the easiest
2605 ;; brute force way to do it.
2606 ;;
2607 ;; This has the undesirable side effect of replacing the tabs
2608 ;; permanently without the user's request or knowledge.
2616 ;;
2623 t)
2624 ;; Get the comment leader on the line and its length
2626 ;; the comment leader is the indentation plus exactly the
2627 ;; number of consecutive ";".
2637 ;; Mark the beginning and end of the paragraph
2643 ;; Move to first line of paragraph
2657 ;; if at end of buffer add a newline (need this because
2658 ;; fill-region needs END to be at the beginning of line after
2659 ;; the paragraph or it will add a line).
2662 ;; Set END to the beginning of line after the paragraph
2663 ;; END is calculated as distance from end of buffer
2665 ;;
2666 ;; Calculate the indentation for the paragraph.
2667 ;;
2668 ;; In the following while statements, after one iteration
2669 ;; point will be at the beginning of a line in which case
2670 ;; the while will not be executed for the
2671 ;; the first paragraph line and thus will not affect the
2672 ;; indentation.
2673 ;;
2674 ;; First check to see if indentation is based on hanging indent.
2680 ;; Adjust lines of paragraph by inserting spaces so that
2681 ;; each line's indent is at least as great as the hanging
2682 ;; indent. This is needed for fill-paragraph to work with
2683 ;; a fill-prefix.
2690 t)
2694 ;; adjust the original location for the
2695 ;; inserted text.
2699 )
2701 ;; No hang. Instead find minimum indentation of paragraph
2702 ;; after first line.
2703 ;; For the following while statement, since START is at the
2704 ;; beginning of line and END is at the the end of line
2705 ;; point is greater than START at least once (which would
2706 ;; be the case for a single line paragraph).
2713 comment-start-skip
2715 t)
2718 )
2721 ? )))
2722 ;; first-line indent
2727 comment-start-skip
2729 t)
2731 indent))
2733 ;; try to keep point at its original place
2736 ;; In place of the more modern fill-region-as-paragraph, a hack
2737 ;; to keep whitespace untouched on the first line within the
2738 ;; indent length and to preserve any indent on the first line
2739 ;; (first indent).
2745 start
2748 nil)
2752 ;; When we want the point at the beginning of the comment
2753 ;; body fill-region will put it at the beginning of the line.
2758 "Calculate the position of the hanging indent for the comment
2759 paragraph. The hanging indent position is given by the first match
2760 with the `idlwave-hang-indent-regexp'. If `idlwave-use-last-hang-indent' is
2761 non-nil then use last occurrence matching `idlwave-hang-indent-regexp' on
2762 the line.
2763 If not found returns nil."
2768 idlwave-hang-indent-regexp
2770 t)
2775 idlwave-hang-indent-regexp
2777 t)
2781 "Called to break lines in auto fill mode.
2782 Only fills comment lines if `idlwave-fill-comment-line-only' is non-nil.
2783 Places a continuation character at the end of the line
2784 if not in a comment. Splits strings with IDL concatenation operator
2785 `+' if `idlwave-auto-fill-split-string is non-nil."
2787 nil ; do not to fill
2790 ;; Check for comment line
2795 ;; Prevent actions do-auto-fill which calls indent-line-function.
2802 ;; Indent the split line
2804 )
2808 ;; A continued line comment
2809 ;; We treat continued line comments as part of a comment
2810 ;; paragraph. So we check for a hanging indent.
2819 ;; Remove whitespace between comment delimiter and
2820 ;; text, insert spaces for appropriate indentation.
2823 comment-start-skip
2828 )))
2829 ;; Split code or comment?
2833 ;; Splitting a non-line comment.
2834 ;; Insert the comment delimiter from split line
2839 ;; Insert blank to keep off beginning of line
2848 ;; Split code line - add continuation character
2851 ;; Check to see if we split a string
2853 idlwave-auto-fill-split-string)
2854 ;; Split the string and concatenate.
2855 ;; The first extra space is for the space
2856 ;; the line was split. That space was removed.
2861 ;; Make the second part of continued string
2866 ;; Warning
2869 ;; Although do-auto-fill (via indent-new-comment-line) calls
2870 ;; idlwave-indent-line for the new line, re-indent again
2871 ;; because of the addition of the continuation character.
2873 )))))
2876 "Toggle auto-fill mode for IDL mode.
2877 With arg, turn auto-fill mode on if arg is positive.
2878 In auto-fill mode, inserting a space at a column beyond `fill-column'
2879 automatically breaks the line at a previous space."
2885 'idlwave-auto-fill
2886 nil))
2887 ;; update mode-line
2891 "Insert a documentation header at the beginning of the unit.
2892 Inserts the value of the variable idlwave-file-header. Sets mark before
2893 moving to do insertion unless the optional prefix argument NOMARK
2894 is non-nil."
2897 ;; make sure we catch the current line if it begins the unit
2901 ;; skip function or procedure line
2914 "Default timestamp insertion function"
2918 ;; Remove extra spaces from line
2920 ;; Insert a blank line comment to separate from the date entry -
2921 ;; will keep the entry from flowing onto date line if re-filled.
2925 "Insert a brief modification log at the beginning of the current program.
2926 Looks for an occurrence of the value of user variable
2927 `idlwave-doc-modifications-keyword' if non-nil. Inserts time and user name
2928 and places the point for the user to add a log. Before moving, saves
2929 location on mark ring so that the user can return to previous point."
2932 ;; make sure we catch the current line if it begins the unit
2939 ;; set search limit at next unit beginning
2941 t)
2943 ;; keyword not present, insert keyword
2954 ;;; CJC 3/16/93
2955 ;;; Interface to expand-region-abbrevs which did not work when the
2956 ;;; abbrev hook associated with an abbrev moves point backwards
2957 ;;; after abbrev expansion, e.g., as with the abbrev '.n'.
2958 ;;; The original would enter an infinite loop in attempting to expand
2959 ;;; .n (it would continually expand and unexpand the abbrev without expanding
2960 ;;; because the point would keep going back to the beginning of the
2961 ;;; abbrev instead of to the end of the abbrev). We now keep the
2962 ;;; abbrev hook from moving backwards.
2963 ;;;
2965 "Expand each abbrev occurrence in the region.
2966 Calling from a program, arguments are START END."
2975 "Returns t if point is in a comment or quoted string.
2976 nil otherwise."
2980 "Returns location of the opening quote
2981 if point is in a IDL string constant, nil otherwise.
2982 Ignores comment delimiters on the current line.
2983 Properly handles nested quotation marks and octal
2984 constants - a double quote followed by an octal digit."
2985 ;;; Treat an octal inside an apostrophe to be a normal string. Treat a
2986 ;;; double quote followed by an octal digit to be an octal constant
2987 ;;; rather than a string. Therefore, there is no terminating double
2988 ;;; quote.
2990 ;; Because single and double quotes can quote each other we must
2991 ;; search for the string start from the beginning of line.
2997 delim
2998 found)
3000 ;; Find string start
3001 ;; Don't find an octal constant beginning with a double quote
3003 ;; Find the string end.
3004 ;; In IDL, two consecutive delimiters after the start of a
3005 ;; string act as an
3006 ;; escape for the delimiter in the string.
3007 ;; Two consecutive delimiters alone (i.e., not after the
3008 ;; start of a string) is the the null string.
3010 ;; Move to position after quote
3013 ;; Get the string delimiter
3015 ;; Check for null string
3018 ;; Look for next unpaired delimiter
3026 ))
3029 ;; return string beginning position or nil
3032 ;; Statement templates
3034 ;; Replace these with a general template function, something like
3035 ;; expand.el (I think there was also something with a name similar to
3036 ;; dmacro.el)
3039 "Build a template with optional prompt expression.
3041 Opens a line if point is not followed by a newline modulo intervening
3042 whitespace. S1 and S2 are strings. S1 is inserted at point followed
3043 by S2. Point is inserted between S1 and S2. The case of S1 and S2 is
3044 adjusted according to `idlwave-abbrev-change-case'. If optional argument
3045 PROMPT is a string then it is displayed as a message in the
3046 minibuffer. The PROMPT serves as a reminder to the user of an
3047 expression to enter.
3049 The lines containing S1 and S2 are reindented using `indent-region'
3050 unless the optional second argument NOINDENT is non-nil."
3056 end)
3069 "Make STRING have the case required by `idlwave-reserved-word-upcase'."
3072 string))
3075 "Build skeleton IDL if-else block."
3083 "Build skeleton IDL case statement."
3091 "Build skeleton for loop statment."
3099 "Build skeleton for loop statment."
3135 "Return a list of substrings of STRING which are separated by PATTERN.
3149 end)
3157 ;; Return the buffer currently visiting FILE
3167 ;; Return a buffer visiting file.
3173 ;; Find FILE on the scanned lib path and return a buffer visiting it
3175 dir efile)
3183 "Creates the IDL tags file IDLTAGS in the current directory from
3184 the list of directories specified in the minibuffer. Directories may be
3185 for example: . /usr/local/rsi/idl/lib. All the subdirectories of the
3186 specified top directories are searched if the directory name is prefixed
3187 by @. Specify @ directories with care, it may take a long, long time if
3188 you specify /."
3191 buffer save_buffer files numfiles item errbuf)
3193 ;;
3194 ;; Read list of directories
3197 ;;
3198 ;; Set etags command, vars
3204 ;;
3205 ;; For each directory
3209 ;;
3210 ;; Find the subdirectories
3232 ;;
3233 ;; For each subdirectory
3237 ;;
3238 ;; Call etags
3246 ;;
3247 ;; Append additional tags
3254 )))
3266 ))
3269 "Comment the lines in the region if the first non-blank line is
3270 commented, and conversely, uncomment region. If optional prefix arg
3271 N is non-nil, then for N positive, add N comment delimiters or for N
3272 negative, remove N comment delimiters.
3273 Uses `comment-region' which does not place comment delimiters on
3274 blank lines."
3281 ;; skip blank lines
3291 ;; ----------------------------------------------------------------------------
3292 ;; ----------------------------------------------------------------------------
3293 ;; ----------------------------------------------------------------------------
3294 ;; ----------------------------------------------------------------------------
3295 ;;
3296 ;; Completion and Routine Info
3297 ;;
3299 ;; String "intern" functions
3301 ;; For the completion and routine info function, we want to normalize
3302 ;; the case of procedure names etc. We do this by "interning" these
3303 ;; string is a hand-crafted way. Hashes are used to map the downcase
3304 ;; version of the strings to the cased versions. Since these cased
3305 ;; versions are really lisp objects, we can use `eq' to search, which
3306 ;; is a large performance boost.
3307 ;; All new strings need to be "sinterned". We do this as early as
3308 ;; possible after getting these strings from completion or buffer
3309 ;; substrings. So most of the code can simply assume to deal with
3310 ;; "sinterned" strings. The only exception is that the functions
3311 ;; which scan whole buffers for routine information do not intern the
3312 ;; grabbed strings. This is only done afterwards. Therefore in these
3313 ;; functions it is *not* save to assume the strings can be compared
3314 ;; with `eq' and be fed into the routine assq functions.
3316 ;; Here we define the hashing functions.
3318 ;; The variables which hold the hashes.
3326 "Reset all sintern hashes."
3327 ;; Make sure the hash functions are accessible.
3339 ;; Make sure these are lists
3346 ;; Reset the system & library hash
3355 ;; Reset the buffer & shell hash
3369 ;;(defmacro idlwave-sintern (type var)
3370 ;; `(cond ((not (stringp name)) name)
3371 ;; ((gethash (downcase name) (cdr ,var)))
3372 ;; ((gethash (downcase name) (car ,var)))
3373 ;; (set (idlwave-sintern-set name ,type ,var set))
3374 ;; (name)))
3411 iname))
3414 "Sintern all strings in the rinfo LIST. With optional parameter SET:
3415 also set new patterns. Probably this will always have to be t."
3429 kwds))
3444 ;;---------------------------------------------------------------------------
3447 ;; The variables which hold the information
3468 ;;
3469 ;; The code to get routine info from different sources.
3473 "Provide a list of IDL routines.
3474 This routine loads the builtin routines on the first call. Later it
3475 only returns the value of the variable."
3479 ;; return the current value
3480 idlwave-routines)))
3483 "Update the internal routine-info lists.
3486 about individual routines.
3488 The information can come from 4 sources:
3489 1. IDL programs in the current editing session
3490 2. Compiled modules in an IDL shell running as Emacs subprocess
3491 3. A list which covers the IDL system routines.
3492 4. A list which covers the prescanned library files.
3494 Scans all IDLWAVE-mode buffers of the current editing session (see
3495 `idlwave-scan-all-buffers-for-routine-info').
3496 When an IDL shell is running, this command also queries the IDL program
3497 for currently compiled routines.
3499 With prefix ARG, also reload the system and library lists.
3500 With two prefix ARG's, also rescans the library tree."
3505 idlwave-buffer-case-takes-precedence
3509 idlwave-compiled-routines nil)
3510 ;; Reset the appropriate hashes
3516 ;; We can safely scan the buffer stuff first
3520 ;; We first do the system info, and then the buffers
3524 ;; Let's see if there is a shell
3528 idlwave-query-shell-for-routine-info)))
3532 ;; 1. If we are not going to ask the shell, we need to do the
3533 ;; concatenation now.
3534 ;; 2. When this function is called non-interactively, it means
3535 ;; that someone needs routine info *now*. The shell update
3536 ;; causes the concatenation *delayed*, so not in time for
3537 ;; the current command. Therefore, we do a concatenation
3538 ;; now, even though the shell might do it again.
3542 ;; Ask the shell about the routines it knows.
3547 ;; Load and case-treat the system and lib info files.
3569 ;; Scan all buffers, current buffer last
3573 ;; Just scan this buffer
3579 ;; Put the result into the correct variable
3584 "Put the different sources for routine information together."
3585 ;; The sequence here is important because earlier definitions shadow
3586 ;; later ones. We assume that if things in the buffers are newer
3587 ;; then in the shell of the system, it is meant to be different.
3588 ;; FIXME: should the builtin stuff be before the library?
3589 ;; This is how IDL searches, the user may also have
3590 ;; functions overloading system stuff, and then the lib
3591 ;; should be first. Difficult to find a general solution.
3592 ;; FIXME: can't we use nconc here in some way, to save memory?
3593 ;; This is possible for buffer abd shell stuff, but these are
3594 ;; small anyway, and so it is not so critical.
3596 idlwave-compiled-routines
3597 idlwave-library-routines
3598 idlwave-builtin-routines))
3605 ;; Give a message with information about the number of routines we have.
3607 "Routine info updated: buffer(%d) compiled(%d) library(%d) system(%d)"
3613 ;;----- Scanning buffers -------------------
3616 "Call `idlwave-get-buffer-routine-info' on idlwave-mode buffers in BUFFERS."
3622 ;; yes, this buffer has the right mode.
3627 ;; Concatenate the individual lists and return the result
3631 "Scan the current buffer for routine info. Return (PRO-LIST FUNC-LIST)."
3633 routine-list string entry)
3647 routine-list))
3650 "Parse a module definition."
3652 start name args type keywords class)
3653 ;; Remove comments
3656 ;; Remove the continuation line stuff
3659 ;; Match the name and type.
3667 ;; Match normal args and keyword args
3670 string start)
3675 ;; Normalize and sort.
3679 ;; Make and return the entry
3680 ;; We don't know which argument are optional, so this information
3681 ;; will not be contained in the calling sequence.
3684 class
3696 "%s"
3704 nil))))
3706 ;;----- Scanning the library -------------------
3709 "Scan all files on selected dirs of IDL search path for routine information.
3710 A widget checklist will allow you to choose the directories.
3711 Write the result as a file `idlwave-libinfo-file'. When this file exists,
3712 will be automatically loaded to give routine information about library
3713 routines.
3714 With ARG, just rescan the same directories as last time - so no widget
3715 will pop up."
3717 ;; Make sure the file is loaded if it exists.
3723 ;; Make sure the file name makes sense
3728 idlwave-libinfo-file))))
3733 ;; Rescan the known directories
3736 ;; Get the directories from that variable
3739 idlwave-scanned-lib-directories))
3741 ;; Ask the shell for the path and run the widget
3744 "__pa=expand_path(!path,/array)&for i=0,n_elements(__pa)-1 do print,'PATH:',__pa[i]"
3749 ;; Command hook used by `idlwave-create-libinfo-file'.
3751 ;; Scan immediately
3753 ;; Display the widget
3755 idlwave-scanned-lib-directories)))
3759 ;; Convert the output of the path query into a list of directories
3763 dirs)
3770 "This is the front-end to the creation of IDLWAVE library routine info.
3771 Please select below the directories on IDL's search path from which you
3772 would like to extract routine information, which will be stored in the file
3774 %s
3776 If this is not the correct file, first set variable `idlwave-libinfo-file'.
3777 Then call this command again.
3778 After selecting the directories, choose [Scan & Save] to scan the library
3779 directories and save the routine info.
3785 "Create the widget to select IDL search path directories for scanning."
3792 ;; Allow only those directories to be selected which are in the path.
3795 selected-dirs)))
3801 idlwave-libinfo-file))
3828 nil))
3836 'checklist
3837 :value selected-dirs
3838 :greedy t
3856 ;; Call `idlwave-scan-lib-files' with data taken from the widget.
3863 ;; Scan the files in SELECTED-DIRS and store the info in a file
3866 dirs dir files file)
3886 idlwave-library-routines)))
3887 )))))
3893 font-lock-mode)
3899 ;; Define the variable which contains a list of all scanned directories
3903 selected-dirs)
3905 ;; Define the routine info list
3910 idlwave-library-routines)
3914 ;; Save the buffer
3919 idlwave-libinfo-file)
3924 ;; Expand parts of path starting with '+' recursively into directory list.
3925 ;; Relative recursive path elements are expanded relative to DEFAULT-DIR.
3935 ;; Expand recursively
3937 ;; Keep unchanged
3943 ;; Return a list of all directories below DIR, including DIR itself
3952 path1))
3954 ;;----- Asking the shell -------------------
3956 ;; First, here is the idl program which can be used to query IDL for
3957 ;; defined routines.
3959 "
3960 function idlwave_make_info_entry,name,func=func,separator=sep
3961 ;; See if it's an object method
3962 func = keyword_set(func)
3963 methsep = strpos(name,'::')
3964 meth = methsep ne -1
3966 ;; Get routine info
3967 pars = routine_info(name,/parameters,functions=func)
3968 source = routine_info(name,/source,functions=func)
3969 nargs = pars.num_args
3970 nkw = pars.num_kw_args
3971 if nargs gt 0 then args = pars.args
3972 if nkw gt 0 then kwargs = pars.kw_args
3974 ;; Trim the class, and make the name
3975 if meth then begin
3976 class = strmid(name,0,methsep)
3977 name = strmid(name,methsep+2,strlen(name)-1)
3978 if nargs gt 0 then begin
3979 ;; remove the self argument
3980 wh = where(args ne 'SELF',nargs)
3981 if nargs gt 0 then args = args(wh)
3982 endif
3983 endif else begin
3984 ;; No class, just a normal routine.
3986 endelse
3988 ;; Calling sequence
3990 if func then cs = 'Result = '
3991 if meth then cs = cs + 'Obj -> [' + '%s' + '::]'
3992 cs = cs + '%s'
3993 if func then cs = cs + '(' else if nargs gt 0 then cs = cs + ', '
3994 if nargs gt 0 then begin
3995 for j=0,nargs-1 do begin
3996 cs = cs + args(j)
3997 if j lt nargs-1 then cs = cs + ', '
3998 endfor
3999 end
4000 if func then cs = cs + ')'
4001 ;; Keyword arguments
4002 kwstring = ''
4003 if nkw gt 0 then begin
4004 for j=0,nkw-1 do begin
4005 kwstring = kwstring + ' ' + kwargs(j)
4006 endfor
4007 endif
4009 ret=(['IDLWAVE-PRO','IDLWAVE-FUN', $
4010 'IDLWAVE-PRO','IDLWAVE-FUN'])(func+2*meth)
4012 return,ret + ': ' + name + sep + class + sep + source(0).path $
4013 + sep + cs + sep + kwstring
4014 end
4016 pro idlwave_routine_info
4017 sep = '<@>'
4019 all = routine_info()
4020 for i=0,n_elements(all)-1 do $
4021 print,idlwave_make_info_entry(all(i),separator=sep)
4022 all = routine_info(/functions)
4023 for i=0,n_elements(all)-1 do $
4024 print,idlwave_make_info_entry(all(i),/func,separator=sep)
4025 print,'>>>END OF IDLWAVE ROUTINE INFO'
4026 end
4027 "
4028 "The idl program to get the routine info stuff.
4032 "Function which parses the special output from idlwave_routine_info.pro."
4035 sep sep-re file type spec specs name cs key keys class)
4036 ;; Initialize variables
4038 ;; Cut out the correct part of the output.
4041 text)
4049 ;; Match the output lines
4068 ;; Make sure we use the same string object for the same file
4070 ;; FIXME: What should I do with routines from the temp file???
4071 ;; Maybe just leave it in - there is a chance that the
4072 ;; routine is still in there.
4073 ;; (if (equal file idlwave-shell-temp-pro-file)
4074 ;; (setq file nil))
4076 ;; In the following ignore routines already defined in buffers,
4077 ;; assuming that if the buffer stuff differs, it is a "new"
4078 ;; version.
4079 ;; We could do the same for the library to avoid duplicates -
4080 ;; but I think frequently a user might have several versions of
4081 ;; the same function in different programs, and in this case the
4082 ;; compiled one will be the best guess of all version.
4083 ;; Therefore, we leave duplicates of library routines in.
4087 ;; FIXME: is it OK to make the buffer routines dominate?
4089 idlwave-buffer-routines))
4090 ;; FIXME: is it OK to make the library routines dominate?
4091 ;;(not (idlwave-rinfo-assq name 'pro class
4092 ;; idlwave-library-routines))
4093 )
4095 idlwave-compiled-routines))
4097 ;; FIXME: is it OK to make the buffer routines dominate?
4099 idlwave-buffer-routines))
4100 ;; FIXME: is it OK to make the library routines dominate?
4101 ;; (not (idlwave-rinfo-assq name 'fun class
4102 ;; idlwave-library-routines))
4103 )
4105 idlwave-compiled-routines)))))
4106 ;; Reverse the definitions so that they are alphabetically sorted.
4112 "Query the shell for routine_info of compiled modules and update the lists."
4113 ;; Save and compile the procedure
4116 idlwave-shell-temp-pro-file))
4123 ;; Execute the procedure and analyze the output
4130 ;; ---------------------------------------------------------------------------
4131 ;;
4132 ;; Completion and displaying routine calling sequences
4135 "Complete a function, procedure or keyword name at point.
4136 This function is smart and figures out what can be legally completed
4137 at this point.
4138 - At the beginning of a statement it completes procedure names.
4139 - In the middle of a statement it completes function names.
4140 - after a `(' or `,' in the argument list of a function or procedure,
4141 it completes a keyword of the relevant function or procedure.
4142 - In the first arg of `OBJ_NEW', it completes a class name.
4144 When several completions are possible, a list will be displayed in the
4145 *Completions* buffer. If this list is too long to fit into the
4148 The function also knows about object methods. When it needs a class
4149 name, the action depends upon `idlwave-query-class', which see. You
4151 argument to this command.
4153 See also the variables `idlwave-keyword-completion-adds-equal' and
4154 `idlwave-function-completion-adds-paren'.
4156 The optional ARG can be used to specify the completion type in order
4157 to override IDLWAVE's idea of what should be completed at point.
4158 Possible values are:
4160 0 <=> query for the completion type
4161 1 <=> 'procedure
4162 2 <=> 'procedure-keyword
4163 3 <=> 'function
4164 4 <=> 'function-keyword
4165 5 <=> 'procedure-method
4166 6 <=> 'procedure-method-keyword
4167 7 <=> 'function-method
4168 8 <=> 'function-method-keyword
4169 9 <=> 'class
4171 For Lisp programmers only:
4172 When we force a keyword, optional argument MODULE can contain the module name.
4173 When we force a method or a method keyword, CLASS can specify the class."
4204 ;; Complete a procedure name
4212 isa
4216 isa
4220 ;; Complete a function name
4228 isa
4232 isa
4236 ;; Complete a procedure keyword
4258 isa
4262 ;; Complete a function keyword
4284 isa
4290 ;; Return an artificial WHERE specification to force the completion
4291 ;; routine to complete a specific item independent of context.
4292 ;; WHAT is the prefix arg of `idlwave-complete', see there for details.
4293 ;; MODULE and CLASS can be used to specify the routine name and class.
4294 ;; The class name will also be found in MODULE if that is like "class::mod".
4312 what)
4381 ;; Completing read, case insensitive
4390 ;; Make a fully qualified module name including the class name
4394 ;; Works like assq, but also checks type and class
4405 "Return a list of all associations of Key in LIST."
4413 "Return all classes which have a method METHOD. TYPE is 'fun or 'pro.
4414 When TYPE is not specified, both procedures and functions will be considered."
4427 "Return all classes which have a method METHOD with keyword KEYWORD.
4428 TYPE is 'fun or 'pro.
4429 When TYPE is not specified, both procedures and functions will be considered."
4432 nil
4444 ;; Determine the class of a routine call. INFO is the structure returned
4445 ;; `idlwave-what-function' or `idlwave-what-procedure'.
4446 ;; The third element in this structure is the class. When nil, we return nil.
4447 ;; When t, try to get the class from text properties at the arrow,
4448 ;; otherwise prompt the user for a class name. Also stores the selected
4449 ;; class as a text property at the arrow.
4450 ;; TYPE is 'fun or 'pro.
4456 idlwave-query-class))
4458 idlwave-query-class))
4464 store class-alist)
4468 ;; There is an object which would like to know its class
4470 idlwave-store-inquired-class
4494 ;; We have a real class here
4499 ;; Return the class
4500 class)
4501 ;; Default as fallback
4513 "Find out where we are.
4514 The return value is a list with the following stuff:
4515 (PRO-LIST FUNC-LIST COMPLETE-WHAT CW-LIST LAST-CHAR)
4517 PRO-LIST (PRO POINT CLASS ARROW)
4518 FUNC-LIST (FUNC POINT CLASS ARROW)
4519 COMPLETE-WHAT a symbol indicating what kind of completion makes sense here
4520 CW-LIST Like PRO-LIST, for what can be copmpleted here.
4521 LAST-CHAR last relevant character before point (non-white non-comment,
4522 not part of current identifier or leading slash).
4524 In the lists, we have these meanings:
4525 PRO: Procedure name
4526 FUNC: Function name
4527 POINT: Where is this
4528 CLASS: What class has the routine (nil=no, t=is method, but class unknown)
4529 ARROW: Where is the arrow?"
4545 cw cw-mod cw-arrow cw-class cw-point)
4552 cw-arrow pro-arrow))
4555 nil)
4564 cw-class func-class cw-arrow func-arrow))
4567 cw-class pro-class cw-arrow pro-arrow))
4568 ; ((member last-char '(?\' ?\) ?\] ?!))
4569 ; ;; after these chars, a function makes no sense
4570 ; ;; FIXME: I am sure there can be more in this list
4571 ; ;; FIXME: Do we want to do this at all?
4572 ; nil)
4573 ;; Everywhere else we try a function.
4581 t))))))
4584 cw
4586 last-char)))
4589 ;; Grab the word around point. CLASS is for the `skip-chars=...' functions
4598 ;; Find out if point is within the argument list of a function.
4599 ;; The return value is ("function-name" (point) level).
4600 ;; Level is 1 on the to level parenthesis, higher further down.
4602 ;; If the optional BOUND is an integer, bound backwards directed
4603 ;; searches to this point.
4607 func-point
4610 func arrow-start class)
4616 ;; move back out of the current parenthesis
4625 bound t))
4628 pos func-point)
4634 'exit
4638 arrow-start func-point cnt)))
4644 ;; Find out if point is within the argument list of a procedure.
4645 ;; The return value is ("procedure-name" class arrow-pos (point)).
4647 ;; If the optional BOUND is an integer, bound backwards directed
4648 ;; searches to this point.
4650 pro class arrow-start string)
4661 "\\`[ \t]*\\(->\\)[ \t]*\\(\\([a-zA-Z][a-zA-Z0-9$_]*\\)::\\)?\\([a-zA-Z][a-zA-Z0-9$_]*\\)?[ \t]*\\(,\\|\\'\\)" string))
4666 pos)
4671 arrow-start
4672 pro-point)))
4675 ;; If there is an object at point, move over it and return t.
4685 nil)
4703 nil)))
4707 "Return the last character before point which is not white or a comment
4708 and also not part of the current identifier. Since we do this in
4709 order to identify places where keywords are, we consider the initial
4710 `/' of a keyword as part of the identifier.
4711 This function is not general, can only be used for completion stuff."
4714 ;; skip the current identifier
4716 ;; also skip a leading slash which might be belong to the keyword
4719 ;; FIXME: does not check if this is a valid identifier
4727 ;; continuation line
4741 "Perform TYPE completion of word before point against LIST.
4742 SELECTOR is the PREDICATE argument for the completion function.
4743 Show PROMPT in echo area. TYPE is one of 'function, 'procedure or 'keyword."
4746 dpart dcompletion)
4751 ;; What is already in the buffer?
4756 idlwave-complete-after-success-form
4759 idlwave-complete-after-success-form-force
4763 ;; Try a completion
4771 ;; nothing available.
4775 ;; We can add something
4779 idlwave-complete-empty-string-as-lower-case)
4784 ;; Now this is a unique match
4786 t)
4792 ;; This is already complete
4795 nil)
4797 ;; We cannot add something - offer a list.
4811 idlwave-complete-empty-string-as-lower-case)
4817 x)
4818 list)))
4820 t))))
4823 "Complete a class at point."
4825 ;; Call `idlwave-routines' to make sure the class list will be available
4827 ;; Now do the completion
4833 ;; attach the proper class list to a LIST of completion items.
4834 ;; IS-KWD, when non-nil, shows its keywords - otherwise its methods
4835 ;; SHOW-CLASSES is the value of `idlwave-completion-show-classes'.
4840 ;; In these cases, we do not have to do anything
4843 ;; The property and dots stuff currently only make sense with XEmacs
4844 ;; because Emacs drops text properties when filling the *Completions*
4845 ;; buffer.
4851 classes nclasses class-info space)
4854 ;; get the classes
4858 method-selector x type-selector)
4861 ;; Make the separator between item and class-info
4866 ;; We do want info in the buffer
4869 space
4874 ;; We do want properties
4878 x))
4881 x))
4882 list))))
4885 ;; Call idlwave-attach-classes with method parameters
4888 ;; Call idlwave-attach-classes with keyword parameters
4891 ;;----------------------------------------------------------------------
4892 ;;----------------------------------------------------------------------
4893 ;;----------------------------------------------------------------------
4894 ;;----------------------------------------------------------------------
4895 ;;----------------------------------------------------------------------
4898 "Scroll the completion window on this frame."
4916 "Display the completions in LIST in the completions buffer and echo MESSAGE."
4926 ;; Store a special value in `this-command'. When `idlwave-complete'
4927 ;; finds this in `last-command', it will scroll the *Completions* buffer.
4930 ;; Mark the completions buffer as created by cib
4933 ;; Fontify the classes
4938 ;; Display the message
4942 "Call FUNCTION as a completion chooser and pass ARGS to it."
4948 "Restore the old (before completion) window configuration."
4950 idlwave-before-completion-wconf
4954 "Set the buffer-local value of VAR in BUFFER to VALUE."
4960 "Return the value of VAR in BUFFER, but only if VAR is local to BUFFER."
4966 ;; In XEmacs, we can use :activate-callback directly
4974 "Execute `default-choose-completion' and then restore the win-conf."
4977 ;; In Emacs we have to replace the keymap in the *Completions* buffer
4978 ;; in order to install our wrappers.
4984 "Display completion list and install the choose wrappers."
4995 "Replace `choose-completion' and `mouse-choose-completion' in OLD-MAP."
5001 new-map))
5004 "Choose the completion that point is in or next to."
5009 "Click on an alternative in the `*Completions*' buffer to choose it."
5013 ;;----------------------------------------------------------------------
5014 ;;----------------------------------------------------------------------
5017 "Goto the *Completions* buffer and fontify the class info."
5031 nlist))
5034 "Add `=' or `(' after successful completion of keyword and function.
5035 Restore the pre-completion window configuration if possible."
5038 nil)
5053 nil)))
5055 ;; Restore the pre-completion window configuration if this is safe.
5071 "Make IDLHELP display the online documentation about the routine at point.
5072 Sends the command `? MODULE' to the IDLWAVE-Shell. Shell must be running,
5073 it does not autostart for this task."
5078 "Display a routines calling sequence and list of keywords.
5079 When point is on the name a function or procedure, or in the argument
5080 list of a function or procedure, this command displays a help buffer
5081 with the information. When called with prefix arg, enforce class
5082 query.
5084 When point is on an object operator `->', display the class stored in
5085 this arrow, if any (see `idlwave-store-inquired-class'). With a
5086 prefix arg, the class property is cleared out."
5093 ;; Cursor is on an arrow
5095 ;; arrow has class property
5097 ;; Remove property
5104 ;; Echo class property
5107 ;; No property found
5110 ;; Not on an arrow...
5122 "Tell IDL to lookup CLASS::NAME with type TYPE in the online help.
5123 If TYPE and CLASS are both nil, just look up NAME in the default help file."
5124 ;; If only the IDLHELP application was better designed, so that
5125 ;; we could make it open the right thing right away. As things are,
5126 ;; we need to pipe the stuff through the help search engine, and we
5127 ;; cannot enter a space.
5130 ;; Try to find a clue for the right help book
5133 name type class idlwave-builtin-routines))
5135 name type class idlwave-routines)))))
5137 ;; Sometimes the book is given as a symbol - make it a string
5140 ;; Add the FULL_PATH keyword if appropriate
5146 ;; We would like to add "Method" or so, but stupid IDL online help
5147 ;; command treats a space as a separator and interprets the next thing as
5148 ;; the book name.
5149 ;; (setq extra (cond ((eq type 'kwd) " keyword")
5150 ;; (class " method")
5151 ;; ((eq type 'pro) " procedure")
5152 ;; ((eq type 'fun) " function")
5153 ;; (t "")))
5156 ;; Methods are subitems of classes, the separator is a single `:'
5159 ;; FIXME: We used to use book, but in idl5.3, all help is in idl.hlp
5162 ; cmd (format "ONLINE_HELP,'%s',BOOK='%s'%s" string book full))
5167 "Call RESOLVE on the module name at point.
5168 Like `idlwave-routine-info', this looks for a routine call at point.
5169 After confirmation in the minibuffer, it will use the shell to issue
5170 a RESOLVE call for this routine, to attempt to make it defined and its
5171 routine info available for IDLWAVE. If the routine is a method call,
5172 both `class__method' and `class__define' will be tried.
5173 With ARG, enforce query for the class of object methods."
5182 class)
5184 resolve)
5188 nil)
5197 'idlwave-update-routine-info
5198 nil t))
5206 nil t))))))
5209 "Find the source code of an IDL module.
5210 Works for modules for which IDLWAVE has routine info available.
5211 The function offers as default the module name `idlwave-routine-info' would
5212 use. With ARG force class query for object methods."
5223 ;; Take out system routines with no source.
5224 nil
5233 list))
5234 type class)
5236 ;; Nothing, use the default.
5253 source buf1 entry
5265 name1))
5268 name1))
5287 nil t)
5294 "Return a default module for stuff near point.
5295 Used by `idlwave-routine-info' and `idlwave-find-module'."
5304 )
5330 ;; This fixes the list of keywords.
5332 name1 type1)
5334 ;; If this is the OBJ_NEW function, try to figure out the class and use
5335 ;; the keywords from the corresponding INIT method.
5341 class)
5343 string)
5349 'fun
5350 class
5353 ;; If the class is `t', combine all keywords of all methods NAME
5364 ;; Return the final list
5365 keywords))
5370 'idlwave-mouse-active-rinfo)
5371 (define-key idlwave-rinfo-map
5372 (if (featurep 'xemacs) [button3] [mouse-3])
5373 'idlwave-mouse-active-rinfo-right)
5374 (defvar idlwave-popup-source)
5376 (defun idlwave-display-calling-sequence (name type class)
5377 ;; Display the calling sequence of module NAME, type TYPE in class CLASS.
5378 (let* ((entry (idlwave-rinfo-assq
5379 name type class (idlwave-routines)))
5380 (name (or (car entry) name))
5381 (class (or (nth 2 entry) class))
5382 (source (nth 3 entry))
5383 ;;(system (eq (car source) 'system))
5384 (calling-seq (nth 4 entry))
5385 (keywords (nth 5 entry))
5386 (olh (nth 6 entry))
5387 (help-echo3 " Button3: IDL Online Help")
5388 (help-echo23 "Button2: Pop to source and back. Button3: IDL Online Help")
5389 (col 0)
5390 (data (list name type class (current-buffer) olh))
5391 (km-prop (if (featurep 'xemacs) 'keymap 'local-map))
5392 beg props win)
5393 (setq keywords (idlwave-fix-keywords name type class keywords))
5394 (cond
5395 ((null entry)
5396 (error "No %s %s known" type name))
5397 ((or (null name) (equal name ""))
5398 (error "No function or procedure call at point."))
5399 ((null calling-seq)
5400 (error "Calling sequence of %s %s is not available" type name))
5401 (t
5402 (save-excursion
5403 (set-buffer (get-buffer-create "*Help*"))
5404 (setq buffer-read-only nil)
5405 (erase-buffer)
5406 (set (make-local-variable 'idlwave-popup-source) nil)
5407 (setq props (list 'mouse-face 'highlight
5408 km-prop idlwave-rinfo-map
5409 'help-echo help-echo23
5410 'data (cons 'usage data)))
5411 (insert "Usage: ")
5412 (setq beg (point))
5413 (insert (if class
5414 (format calling-seq class name)
5415 (format calling-seq name))
5417 (add-text-properties beg (point) props)
5419 (insert "Keywords:")
5420 (if (null keywords)
5421 (insert " No keywords accepted.")
5422 (setq col 9)
5423 (mapcar
5424 (lambda (x)
5425 (if (>= (+ col 1 (length (car x)))
5426 (window-width))
5427 (progn
5429 (setq col 9)))
5430 (insert " ")
5431 (setq beg (point)
5432 props (list 'mouse-face 'highlight
5433 km-prop idlwave-rinfo-map
5434 'data (cons 'keyword data)
5435 'help-echo help-echo3
5436 'keyword (car x)))
5437 (insert (car x))
5438 (add-text-properties beg (point) props)
5439 (setq col (+ col 1 (length (car x)))))
5440 keywords))
5443 (insert "Origin: ")
5444 (setq beg (point)
5445 props (list 'mouse-face 'highlight
5446 km-prop idlwave-rinfo-map
5447 'help-echo help-echo23
5448 'data (cons 'origin data)))
5449 (cond
5450 ((eq (car source) 'system)
5451 (insert "system routine"))
5452 ((equal source '(lib))
5453 (insert (format "library file %s.pro" (downcase name))))
5454 ((eq (car source) 'lib)
5455 (insert "library file ")
5456 (insert (cdr source)))
5457 ((eq (car source) 'buffer)
5458 (insert "buffer visiting ")
5459 (insert (abbreviate-file-name (cdr source))))
5460 ((eq (car source) 'compiled)
5461 (insert "compiled from ")
5462 (insert (cdr source))))
5463 (add-text-properties beg (point) props)
5464 (setq buffer-read-only t))
5465 (display-buffer "*Help*")
5466 (if (and (setq win (get-buffer-window "*Help*"))
5467 idlwave-resize-routine-help-window)
5468 (progn
5469 (let ((ww (selected-window)))
5470 (unwind-protect
5471 (progn
5472 (select-window win)
5473 (enlarge-window (- (/ (frame-height) 2)
5474 (window-height)))
5475 (shrink-window-if-larger-than-buffer))
5476 (select-window ww)))))))))
5478 (defun idlwave-mouse-active-rinfo-right (ev)
5479 (interactive "e")
5480 (idlwave-mouse-active-rinfo ev 'right))
5482 (defun idlwave-mouse-active-rinfo (ev &optional right)
5483 (interactive "e")
5484 (mouse-set-point ev)
5485 (let (data id name type class buf keyword olh bufwin)
5486 (setq data (get-text-property (point) 'data)
5487 keyword (get-text-property (point) 'keyword)
5488 id (car data)
5489 name (nth 1 data)
5490 type (nth 2 data)
5491 class (nth 3 data)
5492 buf (nth 4 data)
5493 olh (nth 5 data)
5494 bufwin (get-buffer-window buf t))
5495 (cond ((or (eq id 'usage) (eq id 'origin))
5496 (if right
5497 (idlwave-search-online-help name type class)
5498 (setq idlwave-popup-source (not idlwave-popup-source))
5499 (if idlwave-popup-source
5500 (condition-case err
5501 (idlwave-do-find-module name type class)
5502 (error
5503 (setq idlwave-popup-source nil)
5504 (if (window-live-p bufwin) (select-window bufwin))
5505 (error (nth 1 err))))
5506 (if bufwin
5507 (select-window bufwin)
5508 (pop-to-buffer buf)))))
5509 ((eq id 'keyword)
5510 (if right
5511 (idlwave-search-online-help keyword 'kwd class olh)
5512 (error "Button2 not active for keywords"))))))
5514 ;; ----------------------------------------------------------------------------
5515 ;;
5516 ;; Additions for use with imenu.el and func-menu.el
5517 ;; (pop-up a list of IDL units in the current file).
5518 ;;
5520 (defun idlwave-prev-index-position ()
5521 "Search for the previous procedure or function.
5522 Return nil if not found. For use with imenu.el."
5523 (save-match-data
5524 (cond
5526 ;; ((idlwave-find-key idlwave-begin-unit-reg 1 'nomark)
5527 (t nil))))
5529 (defun idlwave-unit-name ()
5530 "Return the unit name.
5531 Assumes that point is at the beginning of the unit as found by
5532 `idlwave-prev-index-position'."
5533 (forward-sexp 2)
5534 (forward-sexp -1)
5535 (let ((begin (point)))
5537 (if (fboundp 'buffer-substring-no-properties)
5538 (buffer-substring-no-properties begin (point))
5539 (buffer-substring begin (point)))))
5541 (defun idlwave-function-menu ()
5542 "Use `imenu' or `function-menu' to jump to a procedure or function."
5543 (interactive)
5544 (if (string-match "XEmacs" emacs-version)
5545 (progn
5546 (require 'func-menu)
5547 (function-menu))
5548 (require 'imenu)
5549 (imenu (imenu-choose-buffer-index))))
5551 ;; Here we kack func-menu.el in order to support this new mode.
5552 ;; The latest versions of func-menu.el already have this stuff in, so
5553 ;; we hack only if it is not already there.
5554 (when (fboundp 'eval-after-load)
5555 (eval-after-load "func-menu"
5556 '(progn
5557 (or (assq 'idlwave-mode fume-function-name-regexp-alist)
5558 (not (boundp 'fume-function-name-regexp-idl)) ; avoid problems
5559 (setq fume-function-name-regexp-alist
5560 (cons '(idlwave-mode . fume-function-name-regexp-idl)
5561 fume-function-name-regexp-alist)))
5562 (or (assq 'idlwave-mode fume-find-function-name-method-alist)
5563 (not (fboundp 'fume-find-next-idl-function-name)) ; avoid problems
5564 (setq fume-find-function-name-method-alist
5565 (cons '(idlwave-mode . fume-find-next-idl-function-name)
5566 fume-find-function-name-method-alist))))))
5568 (defun idlwave-edit-in-idlde ()
5569 "Edit the current file in IDL Development environment."
5570 (interactive)
5571 (start-process "idldeclient" nil
5572 idlwave-shell-explicit-file-name "-c" "-e"
5573 (buffer-file-name) "&"))
5575 (defun idlwave-launch-idlhelp ()
5576 "Start the IDLhelp application."
5577 (interactive)
5578 (start-process "idlhelp" nil idlwave-help-application))
5580 ;; Menus - using easymenu.el
5581 (defvar idlwave-mode-menu-def
5582 `("IDLWAVE"
5583 ["PRO/FUNC menu" idlwave-function-menu t]
5584 ("Motion"
5585 ["Subprogram Start" idlwave-beginning-of-subprogram t]
5586 ["Subprogram End" idlwave-end-of-subprogram t]
5587 ["Block Start" idlwave-beginning-of-block t]
5588 ["Block End" idlwave-end-of-block t]
5589 ["Up Block" idlwave-backward-up-block t]
5590 ["Down Block" idlwave-down-block t]
5591 ["Skip Block Backward" idlwave-backward-block t]
5592 ["Skip Block Forward" idlwave-forward-block t])
5593 ("Mark"
5594 ["Subprogram" idlwave-mark-subprogram t]
5595 ["Block" idlwave-mark-block t]
5596 ["Header" idlwave-mark-doclib t])
5597 ("Format"
5598 ["Indent Subprogram" idlwave-indent-subprogram t]
5599 ["(Un)Comment Region" idlwave-toggle-comment-region "C-c ;"]
5600 ["Continue/Split line" idlwave-split-line t]
5601 "--"
5602 ["Toggle Auto Fill" idlwave-auto-fill-mode :style toggle
5603 :selected (symbol-value idlwave-fill-function)])
5604 ("Templates"
5605 ["Procedure" idlwave-procedure t]
5606 ["Function" idlwave-function t]
5607 ["Doc Header" idlwave-doc-header t]
5608 ["Log" idlwave-doc-modification t]
5609 "--"
5610 ["Case" idlwave-case t]
5611 ["For" idlwave-for t]
5612 ["Repeat" idlwave-repeat t]
5613 ["While" idlwave-while t]
5614 "--"
5615 ["Close Block" idlwave-close-block t])
5616 ("Completion / RInfo"
5617 ["Complete" idlwave-complete t]
5618 ("Complete Special"
5619 ["1 Procedure Name" (idlwave-complete 'procedure) t]
5620 ["2 Procedure Keyword" (idlwave-complete 'procedure-keyword) t]
5621 "--"
5622 ["3 Function Name" (idlwave-complete 'function) t]
5623 ["4 Function Keyword" (idlwave-complete 'function-keyword) t]
5624 "--"
5625 ["5 Procedure Method Name" (idlwave-complete 'procedure-method) t]
5626 ["6 Procedure Method Keyword" (idlwave-complete 'procedure-method-keyword) t]
5627 "--"
5628 ["7 Function Method Name" (idlwave-complete 'function-method) t]
5629 ["8 Function Method Keyword" (idlwave-complete 'function-method-keyword) t]
5630 "--"
5631 ["9 Class Name" idlwave-complete-class t])
5632 "--"
5633 ["Show Routine Info" idlwave-routine-info t]
5634 ["Show Routine Doc with IDLHELP" idlwave-routine-info-from-idlhelp t]
5635 "--"
5636 ["Find Routine Source" idlwave-find-module t]
5637 "--"
5638 ["Update Routine Info" idlwave-update-routine-info t]
5639 "--"
5640 "IDL Library Routine Info"
5641 ["Select Library Directories" idlwave-create-libinfo-file t]
5642 ["Scan Directories" (idlwave-update-routine-info '(16)) idlwave-scanned-lib-directories])
5643 "--"
5644 ("External"
5645 ["Generate IDL tags" idlwave-make-tags t]
5646 ["Start IDL shell" idlwave-shell t]
5647 ["Edit file in IDLDE" idlwave-edit-in-idlde t]
5648 ["Launch IDL Help" idlwave-launch-idlhelp t])
5649 "--"
5650 ("Customize"
5651 ["Browse IDLWAVE Group" idlwave-customize t]
5652 "--"
5653 ["Build Full Customize Menu" idlwave-create-customize-menu
5654 (fboundp 'customize-menu-create)])
5655 ("Documentation"
5656 ["Describe Mode" describe-mode t]
5657 ["Abbreviation List" idlwave-list-abbrevs t]
5658 "--"
5659 ["Commentary in idlwave.el" idlwave-show-commentary t]
5660 ["Commentary in idlw-shell.el" idlwave-shell-show-commentary t]
5661 "--"
5662 ["Info" idlwave-info t]
5663 "--"
5664 ["Launch IDL Help" idlwave-launch-idlhelp t])))
5666 (defvar idlwave-mode-debug-menu-def
5667 '("Debug"
5668 ["Start IDL shell" idlwave-shell t]
5669 ["Save and .RUN buffer" idlwave-shell-save-and-run
5670 (and (boundp 'idlwave-shell-automatic-start)
5671 idlwave-shell-automatic-start)]))
5673 (if (or (featurep 'easymenu) (load "easymenu" t))
5674 (progn
5675 (easy-menu-define idlwave-mode-menu idlwave-mode-map
5676 "IDL and WAVE CL editing menu"
5677 idlwave-mode-menu-def)
5678 (easy-menu-define idlwave-mode-debug-menu idlwave-mode-map
5679 "IDL and WAVE CL editing menu"
5680 idlwave-mode-debug-menu-def)))
5682 (defun idlwave-customize ()
5683 "Call the customize function with idlwave as argument."
5684 (interactive)
5685 ;; Try to load the code for the shell, so that we can customize it
5686 ;; as well.
5687 (or (featurep 'idlw-shell)
5688 (load "idlw-shell" t))
5689 (customize-browse 'idlwave))
5691 (defun idlwave-create-customize-menu ()
5692 "Create a full customization menu for IDLWAVE, insert it into the menu."
5693 (interactive)
5694 (if (fboundp 'customize-menu-create)
5695 (progn
5696 ;; Try to load the code for the shell, so that we can customize it
5697 ;; as well.
5698 (or (featurep 'idlw-shell)
5699 (load "idlw-shell" t))
5700 (easy-menu-change
5701 '("IDLWAVE") "Customize"
5702 `(["Browse IDLWAVE group" idlwave-customize t]
5703 "--"
5704 ,(customize-menu-create 'idlwave)
5705 ["Set" Custom-set t]
5706 ["Save" Custom-save t]
5707 ["Reset to Current" Custom-reset-current t]
5708 ["Reset to Saved" Custom-reset-saved t]
5709 ["Reset to Standard Settings" Custom-reset-standard t]))
5711 (error "Cannot expand menu (outdated version of cus-edit.el)")))
5713 (defun idlwave-show-commentary ()
5714 "Use the finder to view the file documentation from `idlwave.el'."
5715 (interactive)
5716 (require 'finder)
5717 (finder-commentary "idlwave.el"))
5719 (defun idlwave-shell-show-commentary ()
5720 "Use the finder to view the file documentation from `idlw-shell.el'."
5721 (interactive)
5722 (require 'finder)
5723 (finder-commentary "idlw-shell.el"))
5725 (defun idlwave-info ()
5726 "Read documentation for IDLWAVE in the info system."
5727 (interactive)
5728 (require 'info)
5729 (Info-goto-node "(idlwave)"))
5731 (defun idlwave-list-abbrevs (arg)
5732 "Show the code abbreviations define in IDLWAVE mode.
5733 This lists all abbrevs where the replacement text differs from the input text.
5734 These are the ones the users want to learn to speed up their writing.
5736 The function does *not* list abbrevs which replace a word with itself
5737 to call a hook. These hooks are used to change the case of words or
5738 to blink the matching `begin', and the user does not need to know them.
5740 With arg, list all abbrevs with the corresponding hook.
5742 This function was written since `list-abbrevs' looks terrible for IDLWAVE mode."
5744 (interactive "P")
5745 (let ((table (symbol-value 'idlwave-mode-abbrev-table))
5746 abbrevs
5747 str rpl func fmt (len-str 0) (len-rpl 0))
5748 (mapatoms
5749 (lambda (sym)
5750 (if (symbol-value sym)
5751 (progn
5752 (setq str (symbol-name sym)
5753 rpl (symbol-value sym)
5754 func (symbol-function sym))
5755 (if arg
5756 (setq func (prin1-to-string func))
5757 (if (and (listp func) (stringp (nth 2 func)))
5758 (setq rpl (concat "EVAL: " (nth 2 func))
5759 func "")
5760 (setq func "")))
5761 (if (or arg (not (string= rpl str)))
5762 (progn
5763 (setq len-str (max len-str (length str)))
5764 (setq len-rpl (max len-rpl (length rpl)))
5765 (setq abbrevs (cons (list str rpl func) abbrevs)))))))
5766 table)
5767 ;; sort the list
5768 (setq abbrevs (sort abbrevs (lambda (a b) (string< (car a) (car b)))))
5769 ;; Make the format
5771 (with-output-to-temp-buffer "*Help*"
5772 (if arg
5773 (progn
5776 (princ (format fmt "KEY" "REPLACE" "HOOK"))
5777 (princ (format fmt "---" "-------" "----")))
5780 (princ (format fmt "KEY" "ACTION" ""))
5781 (princ (format fmt "---" "------" "")))
5782 (mapcar
5783 (lambda (list)
5784 (setq str (car list)
5785 rpl (nth 1 list)
5786 func (nth 2 list))
5787 (princ (format fmt str rpl func)))
5788 abbrevs)))
5789 ;; Make sure each abbreviation uses only one display line
5790 (save-excursion
5791 (set-buffer "*Help*")
5792 (setq truncate-lines t)))
5794 (run-hooks 'idlwave-load-hook)
5796 (provide 'idlwave)
5798 ;;; idlwave.el ends here