@c %**start of header
@setfilename ../info/idlwave
@settitle IDLWAVE User Manual
-@dircategory Emacs
-@direntry
-* IDLWAVE: (idlwave). Major mode and shell for IDL files.
-@end direntry
@synindex ky cp
@syncodeindex vr cp
@syncodeindex fn cp
-@set VERSION 4.14
-@set EDITION 4.14
+@set VERSION 4.15
+@set EDITION 4.15
@set IDLVERSION 5.5
-@set NSYSROUTINES 1322
-@set NSYSKEYWORDS 5952
-@set DATE June 2002
+@set NSYSROUTINES 1324
+@set NSYSKEYWORDS 6129
+@set DATE September 2002
@set AUTHOR J.D. Smith & Carsten Dominik
@set AUTHOR-EMAIL dominik@@astro.uva.nl
@set MAINTAINER J.D. Smith
@set MAINTAINER-EMAIL jdsmith@@as.arizona.edu
@set IDLWAVE-HOMEPAGE http://idlwave.org/
@c %**end of header
-@finalout
-@ifinfo
+@copying
This file documents IDLWAVE, a major mode for editing IDL files with
Emacs, and interacting with an IDL shell run as a subprocess.
Copyright @copyright{} 1999, 2000, 2001, 2002 Free Software Foundation,
Inc.
+@quotation
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or
any later version published by the Free Software Foundation; with no
Documentation License. If you want to distribute this document
separately from the collection, you can do so by adding a copy of the
license to the document, as described in section 6 of the license.
-@end ifinfo
+@end quotation
+@end copying
+
+@dircategory Emacs
+@direntry
+* IDLWAVE: (idlwave). Major mode and shell for IDL files.
+@end direntry
+
+@finalout
@titlepage
@title IDLWAVE User Manual
@page
This is edition @value{EDITION} of the @cite{IDLWAVE User Manual} for
IDLWAVE version @value{VERSION}, @value{DATE}.
-@sp 2
-Copyright @copyright{} 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
-@sp 2
@cindex Copyright, of IDLWAVE
-Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.1 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, with the Front-Cover texts being ``A GNU
-Manual'', and with the Back-Cover Texts as in (a) below. A copy of the
-license is included in the section entitled ``GNU Free Documentation
-License'' in the Emacs manual.
-
-(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
-this GNU Manual, like GNU software. Copies published by the Free
-Software Foundation raise funds for GNU development.''
-
-This document is part of a collection distributed under the GNU Free
-Documentation License. If you want to distribute this document
-separately from the collection, you can do so by adding a copy of the
-license to the document, as described in section 6 of the license.
+@insertcopying
@end titlepage
@contents
* Getting Started:: Tutorial
* The IDLWAVE Major Mode:: The mode to edit IDL programs
* The IDLWAVE Shell:: The mode to run IDL as an inferior program
-* Installation:: How to Install or Upgrade
+* Installation:: How to Install or Upgrade
* Acknowledgements:: Who did what
-* Sources of Routine Info:: How does IDLWAVE know about routine XYZ
+* Sources of Routine Info:: How does IDLWAVE know about routine XYZ
* Configuration Examples:: The user is king...
* Windows and MacOS:: What still works, and how
* Index:: Fast access
Getting Started (Tutorial)
-* Lesson I -- Development Cycle::
-* Lesson II -- Customization::
-* Lesson III -- Library Catalog::
+* Lesson I -- Development Cycle::
+* Lesson II -- Customization::
+* Lesson III -- Library Catalog::
The IDLWAVE Major Mode
Code Formatting
* Code Indentation:: Reflecting the logical structure
-* Continued Statement Indentation::
+* Continued Statement Indentation::
* Comment Indentation:: Special indentation for comment lines
* Continuation Lines:: Splitting statements over lines
* Syntax Highlighting:: Font-lock support
* Case of Completed Words:: CaseOFcomPletedWords
* Object Method Completion and Class Ambiguity:: obj->Method, what?
+* Object Method Completion in the Shell::
* Class and Keyword Inheritance:: obj->Method, _EXTRA=e
* Structure Tag Completion:: Completing state.Tag
Actions
-* Block Boundary Check:: Is the END correct
+* Block Boundary Check:: Is the END statement correct?
* Padding Operators:: Enforcing space around `=' etc
* Case Changes:: Enforcing upper case keywords
* Starting the Shell:: How to launch IDL as a subprocess
* Using the Shell:: Interactively working with the Shell
-* Debugging IDL Programs:: Compilation/Debugging
-* Examining Variables::
-* Custom Expression Examination::
+* Commands Sent to the Shell::
+* Debugging IDL Programs::
+* Examining Variables::
+* Custom Expression Examination::
Debugging IDL Programs
-* Compiling Programs:: Compiling buffers under the shell
-* Breakpoints and Stepping:: Deciding where to stop and look
-* Walking the Calling Stack:: From where was this routine called?
+* Debug Key Bindings::
+* Compiling Programs::
+* Breakpoints and Stepping::
+* Walking the Calling Stack::
Installation
the Interface Definition Language, part of the Common Object Request
Broker Architecture (CORBA)}. It can also be used for editing source
files for the related WAVE/CL language, but with only limited
-support. Note that this package has nothing to do with the Interface
-Definition Language, part of the Common Object Request Broker
-Architecture (CORBA).
+support.
IDLWAVE consists of two main parts: a major mode for editing IDL source
files files (@code{idlwave-mode}) and a mode for running the IDL program
development environment. Here is a brief summary of what IDLWAVE does:
@itemize @bullet
-@item
+@item
Code indentation and formatting.
@item
Three level syntax highlighting support.
-@item
+@item
Context-sensitive display of calling sequences and keywords for more
than 1000 native IDL routines, extendible to any number of additional
routines in your local IDL libraries.
@item
-Name space conflict search, with likelihood ranking.
+Routine name space conflict search, likelihood-of-use ranking.
@item
Fast, context-sensitive online help.
@item
(setq idlwave-help-directory "~/.idlwave")
@end lisp
+@ifhtml
+<A NAME="TUTORIAL"></A>
+@end ifhtml
@node Getting Started, The IDLWAVE Major Mode, IDLWAVE in a Nutshell, Top
@chapter Getting Started (Tutorial)
@cindex Quick-Start
@cindex Getting Started
@menu
-* Lesson I -- Development Cycle::
-* Lesson II -- Customization::
-* Lesson III -- Library Catalog::
+* Lesson I -- Development Cycle::
+* Lesson II -- Customization::
+* Lesson III -- Library Catalog::
@end menu
@node Lesson I -- Development Cycle, Lesson II -- Customization, Getting Started, Getting Started
y1 = y * delta
return, d + floor(m1*30.6)+floor(y1*365.25)+5
end
-
+
function weekday,day,month,year
;; compute weekday number for date
nr = daynr(day,month,year)
return, nr mod 7
end
-
+
pro plot_wday,day,month
;; Plot the weekday of a date in the first 10 years of this century.
years = 2000,+indgen(10)
@section Lesson III: Library Catalog
We have already used the routine info display in the first part of this
-tutorial. This was the key @kbd{C-c ?} which displays information about
+tutorial. This was the key @kbd{C-c ?} which displays information about
the IDL routine near the cursor position. Wouldn't it be nice
to have the same available for your own library routines and for the
huge amount of code in major extension libraries like JHUPL or the
@menu
* Code Indentation:: Reflecting the logical structure
-* Continued Statement Indentation::
+* Continued Statement Indentation::
* Comment Indentation:: Special indentation for comment lines
* Continuation Lines:: Splitting statements over lines
* Syntax Highlighting:: Font-lock support
syntax elements. Left to his or her own devices, a novice IDL
programmer will often conjure code which is very difficult to read and
impossible to adapt. Much can be gleaned from studying available IDL
-code libraries for coding style pointers, but, due to the variety of IDL
-syntax elements, replicating this style can be challenging at best.
-Luckily, IDLWAVE understands the structure IDL code very well, and takes
-care of almost all formatting issues for you. After configuring it to
-match your coding standards, you can rely on it to help keep your code
-neat and organized.
+code libraries for coding style pointers, but, due to the variety of
+IDL syntax elements, replicating this style can be challenging at
+best. Luckily, IDLWAVE understands the structure of IDL code very
+well, and takes care of almost all formatting issues for you. After
+configuring it to match your coding standards, you can rely on it to
+help keep your code neat and organized.
@cindex Foreign code, adapting
@cindex Indentation, of foreign code
@code{PRO}/@code{FUNCTION}/@code{BEGIN} and @code{END}), and
continuation lines.
-@defopt idlwave-main-block-indent (@code{0})
+@defopt idlwave-main-block-indent (@code{0})
Extra indentation for the main block of code. That is the block between
the FUNCTION/PRO statement and the END statement for that program
unit.
c, d
@end example
-You can instruct IDLWAVE when to use this special continuation
+You can instruct IDLWAVE when to avoid using this special continuation
indentation by setting the variable
@code{idlwave-max-extra-continuation-indent}, which specifies the
-maximum additional indentation beyond the basic indent to be tolerated,
-otherwise defaulting to fixed-offset from the enclosing indent (the size
-of which offset is set in @code{idlwave-continuation-indent}). Also,
-since the indentation level is somewhat dynamic in continued statements
-with special continuation indentation, especially if
-@code{idlwave-max-extra-continuation-indent} is small, the key @kbd{C-u
-@key{TAB}} will re-indent all lines in the current statement. Note that
-@code{idlwave-indent-to-open-paren}, if non-nil, overrides the
-@code{idlwave-max-extra-continuation-indent} limit, for parentheses
-only, forcing them always to line up.
+maximum additional indentation beyond the basic indent to be
+tolerated, otherwise defaulting to a fixed-offset from the enclosing
+indent (the size of which offset is set in
+@code{idlwave-continuation-indent}). Also, since the indentation
+level can be somewhat dynamic in continued statements with special
+continuation indentation, especially if
+@code{idlwave-max-extra-continuation-indent} is small, the key
+@kbd{C-u @key{TAB}} will re-indent all lines in the current statement.
+Note that @code{idlwave-indent-to-open-paren}, if non-nil, overrides
+the @code{idlwave-max-extra-continuation-indent} limit, for
+parentheses only, forcing them always to line up.
@defopt idlwave-continuation-indent (@code{2})
@item @code{;;}
@tab Lines starting with two semicolons are indented like the surrounding code.
@item @code{;}
-@tab Lines starting with a single semicolon are indent to a minimum column.
+@tab Lines starting with a single semicolon are indented to a minimum column.
@end multitable
@noindent
@defopt idlwave-use-last-hang-indent (@code{nil})
Non-@code{nil} means use last match on line for
-@code{idlwave-indent-regexp}.
+@code{idlwave-indent-regexp}.
@end defopt
@node Syntax Highlighting, Octals and Highlighting, Continuation Lines, Code Formatting
@defopt idlwave-default-font-lock-items
Items which should be fontified on the default fontification level
-2.
+2.
@end defopt
@node Octals and Highlighting, , Syntax Highlighting, Code Formatting
@cindex Shell, querying for routine info
@kindex C-c C-i
-IDL comes bundled with more than one thousand procedures, functions and
-object methods, and large libraries typically contain hundreds or even
-thousands more. This large command set makes it difficult to remember
-the calling sequence and keywords for routines you use, but IDLWAVE can
-help. It builds up routine information using a wide variety of sources:
-IDLWAVE in fact knows far more about the routines on your system than
-IDL itself. It maintains a list of all built-in routines, with calling
-sequences and keywords@footnote{This list is created by scanning the IDL
-manuals and might contain (very few) errors. Please report any errors
-to the maintainer, so that they can be fixed.}. It also scans Emacs
-buffers and library files for routine definitions, and queries the
-IDLWAVE-Shell for information about routines currently compiled there.
-This information is updated automatically, and so should usually be
-current. To force a global update and refresh the routine information,
-use @kbd{C-c C-i} (@code{idlwave-update-routine-info}).
+IDL comes bundled with more than one thousand procedures, functions
+and object methods, and large libraries typically contain hundreds or
+even thousands more (each with a few to tens of keywords and
+arguments). This large command set can make it difficult to remember
+the calling sequence and keywords for the routines you use, but
+IDLWAVE can help. It builds up routine information using a wide
+variety of sources: IDLWAVE in fact knows far more about the routines
+on your system than IDL itself. It maintains a list of all built-in
+routines, with calling sequences and keywords@footnote{This list is
+created by scanning the IDL manuals and might contain (very few)
+errors. Please report any errors to the maintainer, so that they can
+be fixed.}. It also scans Emacs buffers and library files for routine
+definitions, and queries the IDLWAVE-Shell for information about
+routines currently compiled there. This information is updated
+automatically, and so should usually be current. To force a global
+update and refresh the routine information, use @kbd{C-c C-i}
+(@code{idlwave-update-routine-info}).
@kindex C-c ?
To display the information about a routine, press @kbd{C-c ?}, which
On positions 1,2 and 8, information about the @samp{plot} procedure will
be shown. On positions 3,4, and 7, the @samp{alog} function will be
described, while positions 5 and 6 will investigate the @samp{sin}
-function.
+function.
When you ask for routine information about an object method, and the
method exists in several classes, IDLWAVE queries for the class of the
object, unless the class is already known through a text property on the
@samp{->} operator (@pxref{Object Method Completion and Class
-Ambiguity}), or by having been explicity included in the call
+Ambiguity}), or by having been explicitly included in the call
(e.g. @code{a->myclass::Foo}).
@cindex Calling sequences
@item @i{Other}
@tab Any other routine with a file not known to be on the search path.
@item @i{Unresolved}
-@tab An otherwise unkown routine the shell lists as unresolved
+@tab An otherwise unkown routine the shell lists as unresolved
(referenced, but not compiled).
@end multitable
@item @i{Usage}
@tab If online help is installed, a click with the @emph{right} mouse
button on the @i{Usage:} line will access the help for the
-routine (@pxref{Online Help}).
+routine (@pxref{Online Help}).
@item @i{Keyword}
@tab Online help about keywords is also available with the
@emph{right} mouse button. Clicking on a keyword with the @emph{middle}
For IDL system routines, RSI provides extensive documentation. IDLWAVE
can access an ASCII version of this documentation very quickly and
accurately. This is @emph{much} faster than using the IDL online help
-application, because usually IDLWAVE gets you to the right place in the
-docs directly, without any additional browsing and scrolling. For this
-online help to work, an ASCII version of the IDL documentation, which is
-not part of the standalone IDLWAVE distribution, is required. The
-necessary help files can be downloaded from
+application, because IDLWAVE usually gets you to the right place in the
+documentation directly, without any additional browsing and scrolling.
+For this online help to work, an ASCII version of the IDL documentation,
+which is not part of the standalone IDLWAVE distribution, is required.
+The necessary help files can be downloaded from
@uref{@value{IDLWAVE-HOMEPAGE}, the maintainers webpage}. The text
extracted from the PDF files is fine for normal documentation
paragraphs, but graphics and multiline equations will not be well
@cindex Source code, as online help
@cindex DocLib header, as online help
For routines which are not documented in the IDL manual (for example
-your own routines), the source code is used as help text. If the
-requested information can be found in a (more or less) standard DocLib
-file header, IDLWAVE shows the header (scrolling down to appropriate
-keywords). Otherwise the routine definition statement
+personal or library routines), the source code itself is used as help
+text. If the requested information can be found in a (more or less)
+standard DocLib file header, IDLWAVE shows the header (scrolling down to
+appropriate keyword). Otherwise the routine definition statement
(@code{pro}/@code{function}) is shown.
+@cindex Structure tags, in online help
+@cindex Class tags, in online help
+Help is also available for class structure tags (@code{self.TAG}), and
+generic structure tags, if structure tag completion is enabled
+(@pxref{Structure Tag Completion}). This is implemented by visiting the
+tag within the class or structure definition source itself. Help is not
+available on built-in system class tags.
+
@kindex M-?
In any IDL program (or, as with most IDLWAVE commands, in the IDL
Shell), press @kbd{M-?} (@code{idlwave-context-help}), or click with
@tab Beyond the class name in an @code{OBJ_NEW} call.
@item @i{Executive Command}
@tab An executive command like @code{.RUN}. Mostly useful in the shell.
+@item @i{Structure Tags}
+@tab In structure tags like @code{state.xsize}
+@item @i{Structure Tags}
+@tab In class tags like @code{self.value}.
@item @i{Default}
@tab The routine that would be selected for routine info display.
@end multitable
Routine Info display. Click with @kbd{Mouse-3} on an item to see the
corresponding help (@pxref{Routine Info}).
@item
-When using completion and Emacs pops up a window with possible
-completions, clicking with @kbd{Mouse-3} on a completion item invokes
-help on that item (@pxref{Completion}).
+When using completion and Emacs pops up a @file{*Completions*} buffer
+with possible completions, clicking with @kbd{Mouse-3} on a completion
+item invokes help on that item (@pxref{Completion}). Items for which
+help is available in the online system documentation (vs. just the
+program source itself) will be emphasized (e.g. colored blue).
@end itemize
@noindent
In both cases, a blue face indicates that the item is documented in the
@cindex Completion, ambiguity
@cindex Completion, forcing function name
The only place where completion is ambiguous is procedure/function
-@emph{keywords} versus @emph{functions}. After @samp{plot,x_}, IDLWAVE
-will always assume a keyword to plot. You can force completion of a
-function name at such a location with a prefix arg: @kbd{C-u
-M-@key{TAB}}.
+@emph{keywords} versus @emph{functions}. After @samp{plot,x,_}, IDLWAVE
+will always assume a keyword to @samp{plot}. However, a function is
+also a possible completion here. You can force completion of a function
+name at such a location by using a prefix arg: @kbd{C-u M-@key{TAB}}.
@cindex Scrolling the @file{*Completions*} window
@cindex Completion, scrolling
@kbd{M-@key{TAB}} repeatedly. Online help (if installed) for each
possible completion is available by clicking with @kbd{Mouse-3} on the
item. Items for which system online help (from the IDL manual) is
-available will be displayed in a different font (e.g. colored blue).
-For other items, the corresponding source code or DocLib header will be
-used as the help text.
+available will be emphasized (e.g. colored blue). For other items, the
+corresponding source code or DocLib header will be used as the help
+text.
+
+@cindex Completion, cancelling
+@cindex Cancelling completion
+Completion is not a blocking operation --- you are free to continue
+editing, enter commands, or simply ignore the @file{*Completions*}
+buffer during a completion operation. If, however, the most recent
+command was a completion, @kbd{C-g} will remove the buffer and restore
+the window configuration. You can also remove the buffer at any time
+with no negative consequences.
@defopt idlwave-keyword-completion-adds-equal (@code{t})
Non-@code{nil} means completion automatically adds @samp{=} after
@menu
* Case of Completed Words:: CaseOFcomPletedWords
* Object Method Completion and Class Ambiguity:: obj->Method, what?
+* Object Method Completion in the Shell::
* Class and Keyword Inheritance:: obj->Method, _EXTRA=e
* Structure Tag Completion:: Completing state.Tag
@end menu
completion.
@end defopt
-@node Object Method Completion and Class Ambiguity, Class and Keyword Inheritance, Case of Completed Words, Completion
+@node Object Method Completion and Class Ambiguity, Object Method Completion in the Shell, Case of Completed Words, Completion
@subsection Object Method Completion and Class Ambiguity
@cindex Object methods
@cindex Class ambiguity
@code{idlwave-query-class} can be configured to make such prompting the
default for all methods (not recommended), or selectively for very
common methods for which the number of completing keywords would be too
-large (e.g. @code{Init}). After you have specified the class for a
-particular statement (e.g. when completing the method), IDLWAVE can
-remember it for the rest of the editing session. Subsequent completions
-in the same statement (e.g. keywords) can then reuse this class
-information. This works by placing a text property on the method
-invocation operator @samp{->}, after which the operator will be shown in
-a different face. This is not enabled by default --- the variable
-@code{idlwave-store-inquired-class} can be used to turn it on.
+large (e.g. @code{Init}).
+
+@cindex Saving object class on @code{->}
+@cindex @code{->}
+After you have specified the class for a particular statement (e.g. when
+completing the method), IDLWAVE can remember it for the rest of the
+editing session. Subsequent completions in the same statement
+(e.g. keywords) can then reuse this class information. This works by
+placing a text property on the method invocation operator @samp{->},
+after which the operator will be shown in a different face. This is not
+enabled by default --- the variable @code{idlwave-store-inquired-class}
+can be used to turn it on.
@defopt idlwave-completion-show-classes (@code{1})
Non-@code{nil} means show classes in @file{*Completions*} buffer when
text property.
@end defopt
-@node Class and Keyword Inheritance, Structure Tag Completion, Object Method Completion and Class Ambiguity, Completion
+@node Object Method Completion in the Shell, Class and Keyword Inheritance, Object Method Completion and Class Ambiguity, Completion
+@subsection Object Method Completion in the Shell
+@cindex Method Completion in Shell
+In the IDLWAVE Shell (@pxref{The IDLWAVE Shell}), objects on which
+methods are being invoked have a special property: they must exist as
+variables, and so their class can be determined (for instance, using the
+@code{obj_class()} function). In the Shell, when attempting completion,
+routine info, or online help within a method routine, a query is sent to
+determine the class of the object. If this query is successful, the
+class found will be used to select appropriate completions, routine
+info, or help. If unsuccessful, information from all known classes will
+be used (as in the buffer). Setting the variable
+@code{idlwave-store-inquired-class} can eliminate unnecessary repetitive
+queries for the object's class, and speed up completion.
+
+@node Class and Keyword Inheritance, Structure Tag Completion, Object Method Completion in the Shell, Completion
@subsection Class and Keyword Inheritance
@cindex Inheritance, class
@cindex Keyword inheritance
@emph{chaining}, and is characterized by chained method calls like
@w{@code{self->MySuperClass::SetProperty,_EXTRA=e}}.
-IDLWAVE can accomodate this special synergy between class and keyword
-inheritance: if @code{_EXTRA} or @code{_REF_EXTRA} are detected among a
+IDLWAVE can accommodate this special synergy between class and keyword
+inheritance: if @code{_EXTRA} or @code{_REF_EXTRA} is detected among a
method's keyword parameters, all keywords of superclass versions of the
-method being considered are included in completion. The completion
-buffer will label keywords based on their originating class. The
-variable @code{idlwave-keyword-class-inheritance} can be used to
-configure which methods have keyword inheritance treated in this simple,
-class-driven way. By default, only @code{Init} and
-@code{(Get|Set)Property} are.
+method being considered are included in completion. There is of course
+no guarantee that this type of keyword chaining actually occurrs, but
+for some methods it's a very convenient assumption. The variable
+@code{idlwave-keyword-class-inheritance} can be used to configure which
+methods have keyword inheritance treated in this simple, class-driven
+way. By default, only @code{Init} and @code{(Get|Set)Property} are.
+The completion buffer will label keywords based on their originating
+class.
@defopt idlwave-support-inheritance (@code{t})
Non-@code{nil} means consider inheritance during completion, online help etc.
In many programs, especially those involving widgets, large structures
(e.g. the @samp{state} structure) are used to communicate among
routines. It is very convenient to be able to complete structure tags,
-in the same way as for instance variables of the @samp{self} object
-(@pxref{Object Method Completion and Class Ambiguity}). Add-in code for
-structure tag completion is available in the form of a loadable
+in the same way as for instance variables (tags) of the @samp{self}
+object (@pxref{Object Method Completion and Class Ambiguity}). Add-in
+code for structure tag completion is available in the form of a loadable
completion module: @file{idlw-complete-structtag.el}. Tag completion in
structures is highly ambiguous (much more so than @samp{self}
-completion), so @code{idlw-complete-structtag} makes an unusual and
+completion), so @code{idlw-complete-structtag} makes an unusual and very
specific assumption: the exact same variable name is used to refer to
-the structure in all parts of the program. So, if you consistently
+the structure in all parts of the program. This is entirely unenforced
+by the IDL language, but is a typical convention. If you consistently
refer to the same structure with the same variable name
(e.g. @samp{state}), structure tags which are read from its definition
-can be used for completion.
+in the same file can be used for completion.
Structure tag completion is not enabled by default. To enable it,
simply add the following to your @file{.emacs}:
@lisp
- (add-hook 'idlwave-load-hook
+ (add-hook 'idlwave-load-hook
(lambda () (require 'idlw-complete-structtag)))
@end lisp
+Once enabled, you'll also be able to access online help on the structure
+tags, using the usual methods (@pxref{Online Help}).
+
@node Routine Source, Resolving Routines, Completion, The IDLWAVE Major Mode
@section Routine Source
@cindex Routine source file
@cindex Source file, of a routine
@kindex C-c C-v
In addition to clicking on a @i{Source:} line in the routine info
-window, there is another way to find the source file of a routine. The
-command @kbd{C-c C-v} (@code{idlwave-find-module}) asks for a module
-name, offering the same default as @code{idlwave-routine-info} would
-have used, taken from nearby buffer contents. In the minibuffer,
-specify a complete routine name (including any class part). IDLWAVE
-will display the source file in another window, positioned at the
-routine in question.
+window, there is another way to quickly visit the source file of a
+routine. The command @kbd{C-c C-v} (@code{idlwave-find-module}) asks
+for a module name, offering the same default as
+@code{idlwave-routine-info} would have used, taken from nearby buffer
+contents. In the minibuffer, specify a complete routine name (including
+any class part). IDLWAVE will display the source file in another
+window, positioned at the routine in question.
@cindex Buffers, killing
@cindex Killing autoloaded buffers
Since getting the source of a routine into a buffer is so easy with
IDLWAVE, too many buffers visiting different IDL source files are
sometimes created. The special command @kbd{C-c C-k}
-(@code{idlwave-kill-autoloaded-buffers}) can be used to remove these
-buffers.
+(@code{idlwave-kill-autoloaded-buffers}) can be used to easily remove
+these buffers.
@node Resolving Routines, Code Templates, Routine Source, The IDLWAVE Major Mode
@section Resolving Routines
(add-hook 'idlwave-mode-hook
(lambda ()
(idlwave-define-abbrev "wb" "widget_base()"
- (idlwave-keyword-abbrev 1))
- (idlwave-define-abbrev "ine" "IF N_Elements() EQ 0 THEN"
- (idlwave-keyword-abbrev 11))))
+ (idlwave-keyword-abbrev 1))
+ (idlwave-define-abbrev "ine" "IF N_Elements() EQ 0 THEN"
+ (idlwave-keyword-abbrev 11))))
@end lisp
Notice how the abbreviation (here @emph{wb}) and its expansion
-(@emph{widget_base()}) are given as argument, and the single argument to
+(@emph{widget_base()}) are given as arguments, and the single argument to
@code{idlwave-keyword-abbrev} (here @emph{1}) specifies how far back to
move the point upon expansion (in this example, to put it between the
parentheses).
The abbreviations are expanded in upper or lower case, depending upon
-the variables @code{idlwave-abbrev-change-case} and (for reserved word
-templates) @code{idlwave-reserved-word-upcase} (@pxref{Case Changes}).
+the variables @code{idlwave-abbrev-change-case} and, for reserved word
+templates, @code{idlwave-reserved-word-upcase} (@pxref{Case Changes}).
@defopt idlwave-abbrev-start-char (@code{"\"})
-A single character string used to start abbreviations in abbrev
-mode.
+A single character string used to start abbreviations in abbrev mode.
+Beware of common characters which might naturally occur in sequence with
+abbreviation strings.
@end defopt
@defopt idlwave-abbrev-move (@code{t})
Non-@code{nil} means the abbrev hook can move point, e.g. to end up
-between the parenthesis of a function call.
+between the parentheses of a function call.
@end defopt
@node Actions, Doc Header, Abbreviations, The IDLWAVE Major Mode
@cindex Actions
@cindex Coding standards, enforcing
-@emph{Actions} are special commands which are executed automatically
-while you write code in order to check the structure of the program or
-to enforce coding standards. Most actions which have been implemented
-in IDLWAVE are turned off by default, assuming that the average user
-wants her code the way she writes it. But if you are a lazy typist and
-want your code to adhere to certain standards, actions can be
-helpful.
+@emph{Actions} are special formatting commands which are executed
+automatically while you write code in order to check the structure of
+the program or to enforce coding standards. Most actions which have
+been implemented in IDLWAVE are turned off by default, assuming that the
+average user wants her code the way she writes it. But if you are a
+lazy typist and want your code to adhere to certain standards, actions
+can be helpful.
Actions can be applied in three ways:
@end defopt
@menu
-* Block Boundary Check:: Is the END correct
+* Block Boundary Check:: Is the END statement correct?
* Padding Operators:: Enforcing space around `=' etc
* Case Changes:: Enforcing upper case keywords
@end menu
(idlwave-action-and-binding "\\<\\(pro\\|function\\)\\>[ \t]*\\<"
'(capitalize-word 1) t)
;; Capitalize common block name
- (idlwave-action-and-binding "\\<common\\>[ \t]+\\<"
+ (idlwave-action-and-binding "\\<common\\>[ \t]+\\<"
'(capitalize-word 1) t)))
@end lisp
@cindex Modification timestamp
@cindex Header, for file documentation
@cindex Timestamp, in doc header.
-@cindex Changelog, in doc header.
+@cindex ChangeLog, in doc header.
@kindex C-c C-h
@kindex C-c C-m
versions and thus do not allow the interaction with
Emacs@footnote{Please inform the maintainer if you come up with a way to
make the IDLWAVE shell work on these systems.} --- so the IDLWAVE shell
-currently only works under GNU and Unix.
+currently only works under Unix.
@menu
* Starting the Shell:: How to launch IDL as a subprocess
* Using the Shell:: Interactively working with the Shell
-* Debugging IDL Programs:: Compilation/Debugging
-* Examining Variables::
-* Custom Expression Examination::
+* Commands Sent to the Shell::
+* Debugging IDL Programs::
+* Examining Variables::
+* Custom Expression Examination::
@end menu
@node Starting the Shell, Using the Shell, The IDLWAVE Shell, The IDLWAVE Shell
@code{idlwave-shell} with a prefix argument: @kbd{C-u C-c C-s} or
@kbd{C-u C-c C-l}. If you always want a dedicated frame for the shell
window, configure the variable
-@code{idlwave-shell-use-dedicated-frame}.
+@code{idlwave-shell-use-dedicated-frame}.
To launch a quick IDLWAVE shell directly from a shell prompt without an
IDLWAVE buffer (e.g., as a replacement for running inside an xterm),
@defopt idlwave-shell-command-history-file (@file{~/.idlwhist})
The file in which the command history of the idlwave shell is saved.
@end defopt
-
+
@defopt idlwave-shell-use-dedicated-frame (@code{nil})
Non-@code{nil} means IDLWAVE should use a special frame to display
-shell buffer.
+shell buffer.
@end defopt
@defopt idlwave-shell-frame-parameters
Hook for customizing @code{idlwave-shell-mode}.
@end defopt
-@node Using the Shell, Debugging IDL Programs, Starting the Shell, The IDLWAVE Shell
+@node Using the Shell, Commands Sent to the Shell, Starting the Shell, The IDLWAVE Shell
@section Using the Shell
@cindex Comint
@cindex Shell, basic commands
commands:
@multitable @columnfractions .12 .88
-@item @key{UP}
+@item @key{UP}, @key{M-p}
@tab Cycle backwards in input history
-@item @key{DOWN}
+@item @key{DOWN}, @key{M-n}
@tab Cycle forwards in input history
-@item @kbd{M-p}
-@tab Cycle backwards in input history @emph{matching input}
-@item @kbd{M-n}
-@tab Cycle forwards in input history @emph{matching input}
@item @kbd{M-r}
@tab Previous input matching a regexp
@item @kbd{M-s}
-@tab Next input that matches a regexp
+@tab Next input matching a regexp
@item @kbd{return}
@tab Send input or copy line to current prompt
@item @kbd{C-c C-a}
@end multitable
In addition to these standard @file{comint} commands,
-@code{idlwave-shell-mode} provides many of the commands which simplify
-writing IDL code, including abbreviations, online help, and completion.
-See @ref{Routine Info} and @ref{Online Help} and @ref{Completion} for more
-information on these commands.
+@code{idlwave-shell-mode} provides many of the same commands which
+simplify writing IDL code available in IDLWAVE buffers. This includes
+abbreviations, online help, and completion. See @ref{Routine Info} and
+@ref{Online Help} and @ref{Completion} for more information on these
+commands.
@cindex Completion, in the shell
@cindex Routine info, in the shell
modes.
@end defopt
-@node Debugging IDL Programs, Examining Variables, Using the Shell, The IDLWAVE Shell
+@node Commands Sent to the Shell, Debugging IDL Programs, Using the Shell, The IDLWAVE Shell
+@section Commands Sent to the Shell
+@cindex Commands in shell, showing
+@cindex Showing commands in shell
+
+The IDLWAVE buffers and shell interact very closely. In addition to the
+normal commands you enter at the @code{IDL>} prompt, many other special
+commands are sent to the shell, sometimes as a direct result of invoking
+a key command, menu item, or toolbar button, but also automatically, as
+part of the normal flow of information updates between the buffer and
+shell.
+
+The commands sent include @code{breakpoint}, @code{.step} and other
+debug commands (@pxref{Debugging IDL Programs}), @code{.run} and other
+compilation statements (@pxref{Compiling Programs}), examination
+commands like @code{print} and @code{help} (@pxref{Examining
+Variables}), and other special purpose commands designed to keep
+information on the running shell current.
+
+By default, much of this background shell input and output is hidden
+from the user, but this is configurable. The custom variable
+@code{idlwave-abbrev-show-commands} allows you to configure which
+commands sent to the shell are shown there. For a related customization
+for separating the output of @emph{examine} commands @xref{Examining
+Variables}.
+
+@defopt idlwave-shell-show-commands (@code{'(run misc breakpoint)})
+A list of command types to echo in the shell when sent. Possible values
+are @code{run} for @code{.run}, @code{.compile} and other run commands,
+@code{misc} for lesser used commands like @code{window}, @code{retall},
+etc., @code{breakpoint} for breakpoint setting and clearing commands,
+and @code{debug} for other debug, stepping, and continue commands. In
+addition, if the variable is set to the single symbol @code{'everything},
+all the copious shell input is displayed (which is probably only useful
+for debugging purposes).
+@end defopt
+
+@node Debugging IDL Programs, Examining Variables, Commands Sent to the Shell, The IDLWAVE Shell
@section Debugging IDL Programs
@cindex Debugging
@cindex Keybindings for debugging
@cindex Toolbar
-@kindex C-c C-d
Programs can be compiled, run, and debugged directly from the source
-buffer in Emacs. The IDLWAVE shell installs key bindings both in the
-shell buffer and in all IDL code buffers of the current Emacs session.
-On Emacs versions which support this, it also installs a debugging
-toolbar. The display of the toolbar can be toggled with @kbd{C-c C-d
-C-t} (@code{idlwave-shell-toggle-toolbar}).
+buffer in Emacs. IDLWAVE makes compiling and debugging IDL programs
+far less cumbersome by providing a full-featured,
+key/menu/toolbar-driven interface to commands like @code{breakpoint},
+@code{.step}, @code{.run}, etc.
+
+The IDLWAVE shell installs key bindings both in the shell buffer and in
+all IDL code buffers of the current Emacs session, so debug commands
+work in both places (in the shell, commands operate on the last file
+compiled). On Emacs versions which support this, a debugging toolbar is
+also installed. The display of the toolbar can be toggled with @kbd{C-c
+C-d C-t} (@code{idlwave-shell-toggle-toolbar}).
+
+@defopt idlwave-shell-use-toolbar (@code{t})
+Non-@code{nil} means use the debugging toolbar in all IDL related
+buffers.
+@end defopt
+
+@menu
+* Debug Key Bindings::
+* Compiling Programs::
+* Breakpoints and Stepping::
+* Walking the Calling Stack::
+@end menu
+
+@node Debug Key Bindings, Compiling Programs, Debugging IDL Programs, Debugging IDL Programs
+@subsection Debug Key Bindings
+@kindex C-c C-d
+@cindex Key bindings
The debugging key bindings are by default on the prefix key @kbd{C-c
C-d}, so for example setting a breakpoint is done with @kbd{C-c C-d
-C-b}, compiling a source file with @kbd{C-c C-d C-c}. If you find this
-too much work, you can add bindings for one or more modifier keys which
-is not used by other commands. For example, if you write in
-@file{.emacs}:
+C-b}, and compiling a source file with @kbd{C-c C-d C-c}. If you find
+this too much work, you can easily configure IDLWAVE to use one or more
+modifier keys not in use by other commands, in lieu of the prefix
+@kbd{C-c C-d} (though these bindings will typically also be available
+--- see @code{idlwave-shell-activate-prefix-keybindings}). For example,
+if you write in @file{.emacs}:
@lisp
(setq idlwave-shell-debug-modifiers '(control shift))
@defopt idlwave-shell-debug-modifiers (@code{nil})
List of modifier keys to use for additional binding of debugging
-commands in the shell and source buffers.
+commands in the shell and source buffers. Can be one or more of
+@code{control}, @code{meta}, @code{super}, @code{hyper}, @code{alt}, and
+@code{shift}.
@end defopt
-@defopt idlwave-shell-use-toolbar (@code{t})
-Non-@code{nil} means use the debugging toolbar in all IDL related
-buffers.
-@end defopt
-
-
-@menu
-* Compiling Programs:: Compiling buffers under the shell
-* Breakpoints and Stepping:: Deciding where to stop and look
-* Walking the Calling Stack:: From where was this routine called?
-@end menu
-
-@node Compiling Programs, Breakpoints and Stepping, Debugging IDL Programs, Debugging IDL Programs
+@node Compiling Programs, Breakpoints and Stepping, Debug Key Bindings, Debugging IDL Programs
@subsection Compiling Programs
@cindex Compiling programs
@cindex Programs, compiling
@kindex C-c C-d C-c
In order to compile the current buffer under the IDLWAVE shell, press
@kbd{C-c C-d C-c} (@code{idlwave-save-and-run}). This first saves the
-current buffer and then sends the command @samp{.run path/to/file} to the
-shell. You can also execute @kbd{C-c C-d C-c} from the shell buffer, in
+current buffer and then sends the command @samp{.run path/to/file} to the
+shell. You can also execute @kbd{C-c C-d C-c} from the shell buffer, in
which case the most recently compiled buffer will be saved and
re-compiled.
-When developing or debugging a program, it is often necessary to execute
+When developing or debugging a program, it is often necessary to execute
the same command line many times. A convenient way to do this is
@kbd{C-c C-d C-y} (@code{idlwave-shell-execute-default-command-line}).
This command first resets IDL from a state of interrupted execution by
You can set breakpoints and step through a program with IDLWAVE.
Setting a breakpoint in the current line of the source buffer is done
with @kbd{C-c C-d C-b} (@code{idlwave-shell-break-here}). With a prefix
-arg of 1 (i.e. @kbd{C-1 C-c C-d C-b}, the breakpoint gets a @code{/ONCE}
-keyword, meaning that it will be deleted after first use. With a
-numeric prefix greater than one, the breakpoint will only be active the
-@code{nth} time it is hit. To clear the breakpoint in the current line,
+arg of 1 (i.e. @kbd{C-1 C-c C-d C-b}), the breakpoint gets a
+@code{/ONCE} keyword, meaning that it will be deleted after first use.
+With a numeric prefix greater than one (e.g. @kbd{C-4 C-c C-d C-b}), the
+breakpoint will only be active the @code{nth} time it is hit. With a
+single non-numeric prefix (i.e. @kbd{C-u C-c C-d C-b}), prompt for a
+condition --- an IDL expression to be evaulated and trigger the
+breakpoint only if true. To clear the breakpoint in the current line,
use @kbd{C-c C-d C-d} (@code{idlwave-clear-current-bp}). When executed
from the shell window, the breakpoint where IDL is currently stopped
will be deleted. To clear all breakpoints, use @kbd{C-c C-d C-a}
(@code{idlwave-clear-all-bp}). Breakpoint lines are highlighted in the
-source code.
+source code. Note that IDL places breakpoints as close as possible on
+or after the line you specify. IDLWAVE queries the shell for the actual
+breakpoint location which was set, so the exact line you specify may not
+be marked.
Once the program has stopped somewhere, you can step through it. The
most important stepping commands are @kbd{C-c C-d C-s} to execute one
line of IDL code ("step into"); @kbd{C-c C-d C-n} to step a single line,
treating procedure and function calls as a single step ("step over");
@kbd{C-c C-d C-h} to continue execution to the line at the cursor and
-@kbd{C-c C-d C-r} to continue execution. Here is a summary of the
+@kbd{C-c C-d C-r} to continue execution. @xref{Commands Sent to the
+Shell}, for information on displaying or hiding the breakpoint and
+stepping commands the shell receives. Here is a summary of the
breakpoint and stepping commands:
@multitable @columnfractions .23 .77
for information how to examine the value of variables and expressions on
higher calling stack levels.
+@ifhtml
+<A NAME="EXAMINE"></A>
+@end ifhtml
@node Examining Variables, Custom Expression Examination, Debugging IDL Programs, The IDLWAVE Shell
@section Examining Variables
@cindex @code{PRINT} expressions
or while composing a long command in the IDLWAVE shell. In the latter
case, the command is sent to the shell and its output is visible, but
point remains unmoved in the command being composed --- you can inspect
-the contituents of a command you're building without interrupting the
+the constituents of a command you're building without interrupting the
process of building it! You can even print arbitrary expressions from
older input or output further up in the shell window --- any expression,
variable, number, or function you see can be examined.
@end defopt
@defopt idlwave-shell-output-face
-The face for @code{idlwave-shell-output-overlay}.
+The face for @code{idlwave-shell-output-overlay}.
Allows to choose the font, color and other properties for the most
recent output of IDL when examining an expression."
@end defopt
@defopt idlwave-shell-separate-examine-output (@code{t})
If non-@code{nil}, re-direct the output of examine commands to a special
-@file{*Examine*} buffer, instead of in the shell itself.
+@file{*Examine*} buffer, instead of in the shell itself.
@end defopt
@node Custom Expression Examination, , Examining Variables, The IDLWAVE Shell
@lisp
(add-hook 'idlwave-shell-mode-hook
(lambda ()
- (idlwave-shell-define-key-both [s-down-mouse-2]
- (idlwave-shell-mouse-examine
+ (idlwave-shell-define-key-both [s-down-mouse-2]
+ (idlwave-shell-mouse-examine
"print, size(___,/DIMENSIONS)"))
(idlwave-shell-define-key-both [f9] (idlwave-shell-examine
"print, size(___,/DIMENSIONS)"))
- (idlwave-shell-define-key-both [f10] (idlwave-shell-examine
+ (idlwave-shell-define-key-both [f10] (idlwave-shell-examine
"print,size(___,/TNAME)"))
(idlwave-shell-define-key-both [f11] (idlwave-shell-examine
"help,___,/STRUCTURE"))))
-@end lisp
-
+@end lisp
+
@noindent Now pressing @key{f9}, or middle-mouse dragging with the
@key{SUPER} key depressed, will print the dimensions of the nearby or
highlighted expression. Pressing @key{f10} will give the type string,
@lisp
(setq idlwave-shell-use-dedicated-frame t)
@end lisp
-@item
+@item
The key sequence @kbd{M-@key{TAB}} no longer inserts a TAB character.
Like in many other Emacs modes, @kbd{M-@key{TAB}} now does
completion. Inserting a TAB has therefore been moved to
everything, modernized IDLWAVE with many new features, and developed the
manual.
-@item
+@item
@uref{mailto:jdsmith@@as.arizona.edu, @b{J.D. Smith}}, the current
maintainer, as of version 4.10, helped shape object method completion
and most new features introduced in versions 4.x.
@item
Lubos Pochman <lubos@@rsinc.com>
@item
+Bob Portmann <portmann@@al.noaa.gov>
+@item
Patrick M. Ryan <pat@@jaameri.gsfc.nasa.gov>
@item
Marty Ryba <ryba@@ll.mit.edu>
several places:
@enumerate
-@item
+@item
@emph{Builtin routines} are defined inside IDL itself. The source
code of such routines is not available.
@item
-Routines which are @emph{part of the current program}, defined in a
-file which is explicitly compiled by the user. This file may or may not
-be located on the IDL search path.
-@item
+Routines which are @emph{part of the current program}, are defined in a
+file explicitly compiled by the user. This file may or may not be
+located on the IDL search path.
+@item
@emph{Library routines} are defined in files located on IDL's search
-path, and will need not be manually compiled. When a library routine is
-called for the first time, IDL will find the source file and compile it
-dynamically. A special sub-category of library routines are the
+path, and will not need to be manually compiled. When a library routine
+is called for the first time, IDL will find the source file and compile
+it dynamically. A special sub-category of library routines are the
@emph{system routines} distributed with IDL, and usually available in
the @file{lib} subdirectory of the IDL distribution.
@item
@file{idlw-rinfo.el}. @xref{Documentation Scan}, for information on how
to regenerate this file for new versions of IDL.
-@item
+@item
It @emph{scans} all @emph{buffers} of the current Emacs session for
routine definitions. This is done automatically when routine
information or completion is first requested by the user. Each new
and completion info of some libraries, it is sufficient to scan those
directories. However, if you want IDLWAVE to detect possible name
conflicts with routines defined in other libraries, the whole pass
-should be scanned.
+should be scanned.
After selecting directories, click on the @w{@samp{[Scan & Save]}}
button in the widget to scan all files in the selected directories and
selected directories, write an updated version of the libinfo file and
rebuild IDLWAVE's internal lists. If you give three prefix arguments
@w{@kbd{C-u C-u C-u C-c C-i}}, updating will be done with a background
-job@footnote{GNU and Unix systems only, I think.}. You can continue to work,
+job@footnote{Unix systems only, I think.}. You can continue to work,
and the library catalog will be re-read when it is ready.
A note of caution: Depending on your local installation, the IDL
@end defopt
@defopt idlwave-library-path
-IDL library path for Windows and MacOS. Not needed under GNU and Unix.
+IDL library path for Windows and MacOS. Not needed under Unix.
@end defopt
@defopt idlwave-system-directory
-The IDL system directory for Windows and MacOS. Not needed under GNU and Unix.
+The IDL system directory for Windows and MacOS. Not needed under Unix.
@end defopt
@defopt idlwave-special-lib-alist
on the load path is routine info display (@pxref{Routine Info}).
@node Documentation Scan, , Load-Path Shadows, Sources of Routine Info
-@appendixsec Documentation Scan
+@appendixsec Documentation Scan
@cindex @file{get_rinfo}
@cindex @file{idlw-rinfo.el}
@cindex @file{idlw-help.txt}
(setq idlwave-main-block-indent 3)
(setq idlwave-end-offset -3)
(setq idlwave-continuation-indent 1)
-(setq idlwave-begin-line-comment "^;[^;]") ; Leave ";" but not ";;"
+(setq idlwave-begin-line-comment "^;[^;]") ; Leave ";" but not ";;"
; anchored at start of line.
(setq idlwave-surround-by-blank t) ; Turn on padding ops =,<,>
(setq idlwave-pad-keyword nil) ; Remove spaces for keyword '='
;; (local-set-key "\C-j" 'idlwave-newline) ; My preference.
;; Some personal abbreviations
- (define-abbrev idlwave-mode-abbrev-table
+ (define-abbrev idlwave-mode-abbrev-table
(concat idlwave-abbrev-start-char "wb") "widget_base()"
(idlwave-keyword-abbrev 1))
- (define-abbrev idlwave-mode-abbrev-table
+ (define-abbrev idlwave-mode-abbrev-table
(concat idlwave-abbrev-start-char "on") "obj_new()"
(idlwave-keyword-abbrev 1))
))
(add-hook 'idlwave-shell-mode-hook
(lambda ()
;; Set up some custom key and mouse examine commands
- (idlwave-shell-define-key-both [s-down-mouse-2]
- (idlwave-shell-mouse-examine
+ (idlwave-shell-define-key-both [s-down-mouse-2]
+ (idlwave-shell-mouse-examine
"print, size(___,/DIMENSIONS)"))
(idlwave-shell-define-key-both [f9] (idlwave-shell-examine
"print, size(___,/DIMENSIONS)"))
- (idlwave-shell-define-key-both [f10] (idlwave-shell-examine
+ (idlwave-shell-define-key-both [f10] (idlwave-shell-examine
"print,size(___,/TNAME)"))
(idlwave-shell-define-key-both [f11] (idlwave-shell-examine
"help,___,/STRUCTURE"))))
@end example
+@ifhtml
+<A NAME="WIN_MAC"></A>
+@end ifhtml
@node Windows and MacOS, Index, Configuration Examples, Top
@appendix Windows and MacOS
@cindex Windows
systems like Windows (with NTEmacs or NTXEmacs) or MacOS.
The only problem really is that RSI does not provide a command-line
-version of IDL for Windows or MacOS which IDLWAVE can interact
-with@footnote{Call your RSI representative and complain --- it should be
-trivial for them to provide one. And if enough people ask for it, maybe
-they will. The upcoming IDL for Mac OSX is slated to have a
-command-line version.}. Therefore the IDLWAVE Shell does not work and
-you have to rely on IDLDE to run and debug your programs. However,
-editing IDL source files with Emacs/IDLWAVE works with all bells and
-whistles, including routine info, completion and fast online help. Only
-a small amount of additional information must be specified in your
-.emacs file: you must specify path names which on a GNU or UNIX system
-are automatically gathered by talking to the IDL program.
+version of IDL for Windows or MacOS with which IDLWAVE can
+interact@footnote{Call your RSI representative and complain --- it
+should be trivial for them to provide one. And if enough people ask
+for it, maybe they will. The upcoming IDL for Mac OSX is slated to
+have a command-line version.}. Therefore the IDLWAVE Shell does not
+work and you have to rely on IDLDE to run and debug your programs.
+However, editing IDL source files with Emacs/IDLWAVE works with all
+bells and whistles, including routine info, completion and fast online
+help. Only a small amount of additional information must be specified
+in your .emacs file: the path names which, on a UNIX system, are
+automatically gathered by talking to the IDL program.
Here is an example of the additional configuration needed for a Windows
system. I am assuming that IDLWAVE has been installed in
@w{@samp{C:\RSI\IDL55}}.
@lisp
-;; location of the lisp files (needed if IDLWAVE is not part of
+;; location of the lisp files (needed if IDLWAVE is not part of
;; the X/Emacs installation)
(setq load-path (cons "c:/program files/IDLWAVE" load-path))
sure you check the following things:
@itemize @bullet
-@item When you download the IDLWAVE distribution, make sure you save the
+@item When you download the IDLWAVE distribution, make sure you save the
files under the names @file{idlwave.tar.gz} and
@file{idlwave-help-tar.gz}.
@item Be sure that your software for untarring/ungzipping is @emph{NOT}
HCoop / bpt / emacs.git / blobdiff