-\1f
-File: xemacs.info, Node: Tags Search, Next: List Tags, Prev: Find Tag, Up: Tags
-
-Searching and Replacing with Tags Tables
-----------------------------------------
-
- The commands in this section visit and search all the files listed
-in the selected tags table, one by one. For these commands, the tags
-table serves only to specify a sequence of files to search. A related
-command is `M-x grep' (*note Compilation::.).
-
-`M-x tags-search <RET> REGEXP <RET>'
- Search for REGEXP through the files in the selected tags table.
-
-`M-x tags-query-replace <RET> REGEXP <RET> REPLACEMENT <RET>'
- Perform a `query-replace-regexp' on each file in the selected tags
- table.
-
-`M-,'
- Restart one of the commands above, from the current location of
- point (`tags-loop-continue').
-
- `M-x tags-search' reads a regexp using the minibuffer, then searches
-for matches in all the files in the selected tags table, one file at a
-time. It displays the name of the file being searched so you can
-follow its progress. As soon as it finds an occurrence, `tags-search'
-returns.
-
- Having found one match, you probably want to find all the rest. To
-find one more match, type `M-,' (`tags-loop-continue') to resume the
-`tags-search'. This searches the rest of the current buffer, followed
-by the remaining files of the tags table.
-
- `M-x tags-query-replace' performs a single `query-replace-regexp'
-through all the files in the tags table. It reads a regexp to search
-for and a string to replace with, just like ordinary `M-x
-query-replace-regexp'. It searches much like `M-x tags-search', but
-repeatedly, processing matches according to your input. *Note
-Replace::, for more information on query replace.
-
- It is possible to get through all the files in the tags table with a
-single invocation of `M-x tags-query-replace'. But often it is useful
-to exit temporarily, which you can do with any input event that has no
-special query replace meaning. You can resume the query replace
-subsequently by typing `M-,'; this command resumes the last tags search
-or replace command that you did.
-
- The commands in this section carry out much broader searches than the
-`find-tag' family. The `find-tag' commands search only for definitions
-of tags that match your substring or regexp. The commands
-`tags-search' and `tags-query-replace' find every occurrence of the
-regexp, as ordinary search commands and replace commands do in the
-current buffer.
-
- These commands create buffers only temporarily for the files that
-they have to search (those which are not already visited in Emacs
-buffers). Buffers in which no match is found are quickly killed; the
-others continue to exist.
-
- It may have struck you that `tags-search' is a lot like `grep'. You
-can also run `grep' itself as an inferior of Emacs and have Emacs show
-you the matching lines one by one. This works much like running a
-compilation; finding the source locations of the `grep' matches works
-like finding the compilation errors. *Note Compilation::.
-
- If you wish to process all the files in a selected tags table, but
-`M-x tags-search' and `M-x tags-query-replace' are not giving you the
-desired result, you can use `M-x next-file'.
-
-`C-u M-x next-file'
- With a numeric argument, regardless of its value, visit the first
- file in the tags table and prepare to advance sequentially by
- files.
-
-`M-x next-file'
- Visit the next file in the selected tags table.
-
-\1f
-File: xemacs.info, Node: List Tags, Prev: Tags Search, Up: Tags
-
-Tags Table Inquiries
---------------------
-
-`M-x list-tags'
- Display a list of the tags defined in a specific program file.
-
-`M-x tags-apropos'
- Display a list of all tags matching a specified regexp.
-
- `M-x list-tags' reads the name of one of the files described by the
-selected tags table, and displays a list of all the tags defined in that
-file. The "file name" argument is really just a string to compare
-against the names recorded in the tags table; it is read as a string
-rather than a file name. Therefore, completion and defaulting are not
-available, and you must enter the string the same way it appears in the
-tag table. Do not include a directory as part of the file name unless
-the file name recorded in the tags table contains that directory.
-
- `M-x tags-apropos' is like `apropos' for tags. It reads a regexp,
-then finds all the tags in the selected tags table whose entries match
-that regexp, and displays the tag names found.
-
-\1f
-File: xemacs.info, Node: Fortran, Next: Asm Mode, Prev: Tags, Up: Programs
-
-Fortran Mode
-============
-
- Fortran mode provides special motion commands for Fortran statements
-and subprograms, and indentation commands that understand Fortran
-conventions of nesting, line numbers, and continuation statements.
-
- Special commands for comments are provided because Fortran comments
-are unlike those of other languages.
-
- Built-in abbrevs optionally save typing when you insert Fortran
-keywords.
-
- Use `M-x fortran-mode' to switch to this major mode. Doing so calls
-the value of `fortran-mode-hook' as a function of no arguments if that
-variable has a non-`nil' value.
-
-* Menu:
-
-* Motion: Fortran Motion. Moving point by statements or subprograms.
-* Indent: Fortran Indent. Indentation commands for Fortran.
-* Comments: Fortran Comments. Inserting and aligning comments.
-* Columns: Fortran Columns. Measuring columns for valid Fortran.
-* Abbrev: Fortran Abbrev. Built-in abbrevs for Fortran keywords.
-
- Fortran mode was contributed by Michael Prange.
-
-\1f
-File: xemacs.info, Node: Fortran Motion, Next: Fortran Indent, Prev: Fortran, Up: Fortran
-
-Motion Commands
----------------
-
- Fortran mode provides special commands to move by subprograms
-(functions and subroutines) and by statements. There is also a command
-to put the region around one subprogram, which is convenient for
-killing it or moving it.
-
-`C-M-a'
- Move to beginning of subprogram
- (`beginning-of-fortran-subprogram').
-
-`C-M-e'
- Move to end of subprogram (`end-of-fortran-subprogram').
-
-`C-M-h'
- Put point at beginning of subprogram and mark at end
- (`mark-fortran-subprogram').
-
-`C-c C-n'
- Move to beginning of current or next statement (`fortran-next-
- statement').
-
-`C-c C-p'
- Move to beginning of current or previous statement (`fortran-
- previous-statement').
-
-\1f
-File: xemacs.info, Node: Fortran Indent, Next: Fortran Comments, Prev: Fortran Motion, Up: Fortran
-
-Fortran Indentation
--------------------
-
- Special commands and features are available for indenting Fortran
-code. They make sure various syntactic entities (line numbers, comment
-line indicators, and continuation line flags) appear in the columns
-that are required for standard Fortran.
-
-* Menu:
-
-* Commands: ForIndent Commands. Commands for indenting Fortran.
-* Numbers: ForIndent Num. How line numbers auto-indent.
-* Conv: ForIndent Conv. Conventions you must obey to avoid trouble.
-* Vars: ForIndent Vars. Variables controlling Fortran indent style.
-
-\1f
-File: xemacs.info, Node: ForIndent Commands, Next: ForIndent Num, Prev: Fortran Indent, Up: Fortran Indent
-
-Fortran Indentation Commands
-............................
-
-`<TAB>'
- Indent the current line (`fortran-indent-line').
-
-`M-<LFD>'
- Break the current line and set up a continuation line.
-
-`C-M-q'
- Indent all the lines of the subprogram point is in
- (`fortran-indent-subprogram').
-
- <TAB> is redefined by Fortran mode to reindent the current line for
-Fortran (`fortran-indent-line'). Line numbers and continuation markers
-are indented to their required columns, and the body of the statement
-is independently indented, based on its nesting in the program.
-
- The key `C-M-q' is redefined as `fortran-indent-subprogram', a
-command that reindents all the lines of the Fortran subprogram
-(function or subroutine) containing point.
-
- The key `M-<LFD>' is redefined as `fortran-split-line', a command to
-split a line in the appropriate fashion for Fortran. In a non-comment
-line, the second half becomes a continuation line and is indented
-accordingly. In a comment line, both halves become separate comment
-lines.
-
-\1f
-File: xemacs.info, Node: ForIndent Num, Next: ForIndent Conv, Prev: ForIndent Commands, Up: Fortran Indent
-
-Line Numbers and Continuation
-.............................
-
- If a number is the first non-whitespace in the line, it is assumed
-to be a line number and is moved to columns 0 through 4. (Columns are
-always counted from 0 in XEmacs.) If the text on the line starts with
-the conventional Fortran continuation marker `$', it is moved to column
-5. If the text begins with any non whitespace character in column 5,
-it is assumed to be an unconventional continuation marker and remains
-in column 5.
-
- Line numbers of four digits or less are normally indented one space.
-This amount is controlled by the variable `fortran-line-number-indent',
-which is the maximum indentation a line number can have. Line numbers
-are indented to right-justify them to end in column 4 unless that would
-require more than the maximum indentation. The default value of the
-variable is 1.
-
- Simply inserting a line number is enough to indent it according to
-these rules. As each digit is inserted, the indentation is recomputed.
-To turn off this feature, set the variable
-`fortran-electric-line-number' to `nil'. Then inserting line numbers
-is like inserting anything else.
-
-\1f
-File: xemacs.info, Node: ForIndent Conv, Next: ForIndent Vars, Prev: ForIndent Num, Up: Fortran Indent
-
-Syntactic Conventions
-.....................
-
- Fortran mode assumes that you follow certain conventions that
-simplify the task of understanding a Fortran program well enough to
-indent it properly:
-
- * Two nested `do' loops never share a `continue' statement.
-
- * The same character appears in column 5 of all continuation lines.
- It is the value of the variable `fortran-continuation-char'. By
- default, this character is `$'.
-
-If you fail to follow these conventions, the indentation commands may
-indent some lines unaesthetically. However, a correct Fortran program
-will retain its meaning when reindented even if the conventions are not
-followed.
-
-\1f
-File: xemacs.info, Node: ForIndent Vars, Prev: ForIndent Conv, Up: Fortran Indent
-
-Variables for Fortran Indentation
-.................................
-
- Several additional variables control how Fortran indentation works.
-
-`fortran-do-indent'
- Extra indentation within each level of `do' statement (the default
- is 3).
-
-`fortran-if-indent'
- Extra indentation within each level of `if' statement (the default
- is 3).
-
-`fortran-continuation-indent'
- Extra indentation for bodies of continuation lines (the default is
- 5).
-
-`fortran-check-all-num-for-matching-do'
- If this is `nil', indentation assumes that each `do' statement
- ends on a `continue' statement. Therefore, when computing
- indentation for a statement other than `continue', it can save
- time by not checking for a `do' statement ending there. If this
- is non-`nil', indenting any numbered statement must check for a
- `do' that ends there. The default is `nil'.
-
-`fortran-minimum-statement-indent'
- Minimum indentation for Fortran statements. For standard Fortran,
- this is 6. Statement bodies are always indented at least this
- much.
-
-\1f
-File: xemacs.info, Node: Fortran Comments, Next: Fortran Columns, Prev: Fortran Indent, Up: Fortran
-
-Comments
---------
-
- The usual Emacs comment commands assume that a comment can follow a
-line of code. In Fortran, the standard comment syntax requires an
-entire line to be just a comment. Therefore, Fortran mode replaces the
-standard Emacs comment commands and defines some new variables.
-
- Fortran mode can also handle a non-standard comment syntax where
-comments start with `!' and can follow other text. Because only some
-Fortran compilers accept this syntax, Fortran mode will not insert such
-comments unless you have specified to do so in advance by setting the
-variable `comment-start' to `"!"' (*note Variables::.).
-
-`M-;'
- Align comment or insert new comment (`fortran-comment-indent').
-
-`C-x ;'
- Applies to nonstandard `!' comments only.
-
-`C-c ;'
- Turn all lines of the region into comments, or (with arg) turn
- them back into real code (`fortran-comment-region').
-
- `M-;' in Fortran mode is redefined as the command
-`fortran-comment-indent'. Like the usual `M-;' command, it recognizes
-an existing comment and aligns its text appropriately. If there is no
-existing comment, a comment is inserted and aligned.
-
- Inserting and aligning comments is not the same in Fortran mode as in
-other modes. When a new comment must be inserted, a full-line comment
-is inserted if the current line is blank. On a non-blank line, a
-non-standard `!' comment is inserted if you previously specified you
-wanted to use them. Otherwise a full-line comment is inserted on a new
-line before the current line.
-
- Non-standard `!' comments are aligned like comments in other
-languages, but full-line comments are aligned differently. In a
-standard full-line comment, the comment delimiter itself must always
-appear in column zero. What can be aligned is the text within the
-comment. You can choose from three styles of alignment by setting the
-variable `fortran-comment-indent-style' to one of these values:
-
-`fixed'
- The text is aligned at a fixed column, which is the value of
- `fortran-comment-line-column'. This is the default.
-
-`relative'
- The text is aligned as if it were a line of code, but with an
- additional `fortran-comment-line-column' columns of indentation.
-
-`nil'
- Text in full-line columns is not moved automatically.
-
- You can also specify the character to be used to indent within
-full-line comments by setting the variable `fortran-comment-indent-char'
-to the character you want to use.
-
- Fortran mode introduces two variables `comment-line-start' and
-`comment-line-start-skip', which do for full-line comments what
-`comment-start' and `comment-start-skip' do for ordinary text-following
-comments. Normally these are set properly by Fortran mode, so you do
-not need to change them.
-
- The normal Emacs comment command `C-x ;' has not been redefined. It
-can therefore be used if you use `!' comments, but is useless in
-Fortran mode otherwise.
-
- The command `C-c ;' (`fortran-comment-region') turns all the lines
-of the region into comments by inserting the string `C$$$' at the front
-of each one. With a numeric arg, the region is turned back into live
-code by deleting `C$$$' from the front of each line. You can control
-the string used for the comments by setting the variable
-`fortran-comment-region'. Note that here we have an example of a
-command and a variable with the same name; the two uses of the name
-never conflict because in Lisp and in Emacs it is always clear from the
-context which one is referred to.
-
-\1f
-File: xemacs.info, Node: Fortran Columns, Next: Fortran Abbrev, Prev: Fortran Comments, Up: Fortran
-
-Columns
--------
-
-`C-c C-r'
- Displays a "column ruler" momentarily above the current line
- (`fortran-column-ruler').
-
-`C-c C-w'
- Splits the current window horizontally so that it is 72 columns
- wide. This may help you avoid going over that limit
- (`fortran-window-create').
-
- The command `C-c C-r' (`fortran-column-ruler') shows a column ruler
-above the current line. The comment ruler consists of two lines of
-text that show you the locations of columns with special significance
-in Fortran programs. Square brackets show the limits of the columns for
-line numbers, and curly brackets show the limits of the columns for the
-statement body. Column numbers appear above them.
-
- Note that the column numbers count from zero, as always in XEmacs.
-As a result, the numbers may not be those you are familiar with; but the
-actual positions in the line are standard Fortran.
-
- The text used to display the column ruler is the value of the
-variable `fortran-comment-ruler'. By changing this variable, you can
-change the display.
-
- For even more help, use `C-c C-w' (`fortran-window-create'), a
-command which splits the current window horizontally, resulting in a
-window 72 columns wide. When you edit in this window, you can
-immediately see when a line gets too wide to be correct Fortran.
-
-\1f
-File: xemacs.info, Node: Fortran Abbrev, Prev: Fortran Columns, Up: Fortran
-
-Fortran Keyword Abbrevs
------------------------
-
- Fortran mode provides many built-in abbrevs for common keywords and
-declarations. These are the same sort of abbrevs that you can define
-yourself. To use them, you must turn on Abbrev mode. *note Abbrevs::..
-
- The built-in abbrevs are unusual in one way: they all start with a
-semicolon. You cannot normally use semicolon in an abbrev, but Fortran
-mode makes this possible by changing the syntax of semicolon to "word
-constituent".
-
- For example, one built-in Fortran abbrev is `;c' for `continue'. If
-you insert `;c' and then insert a punctuation character such as a space
-or a newline, the `;c' changes automatically to `continue', provided
-Abbrev mode is enabled.
-
- Type `;?' or `;C-h' to display a list of all built-in Fortran
-abbrevs and what they stand for.
-
-\1f
-File: xemacs.info, Node: Asm Mode, Prev: Fortran, Up: Programs
-
-Asm Mode
-========
-
- Asm mode is a major mode for editing files of assembler code. It
-defines these commands:
-
-`<TAB>'
- `tab-to-tab-stop'.
-
-`<LFD>'
- Insert a newline and then indent using `tab-to-tab-stop'.
-
-`:'
- Insert a colon and then remove the indentation from before the
- label preceding colon. Then do `tab-to-tab-stop'.
-
-`;'
- Insert or align a comment.
-
- The variable `asm-comment-char' specifies which character starts
-comments in assembler syntax.
-
-\1f
-File: xemacs.info, Node: Running, Next: Packages, Prev: Programs, Up: Top
-
-Compiling and Testing Programs
-******************************
-
- The previous chapter discusses the Emacs commands that are useful for
-making changes in programs. This chapter deals with commands that
-assist in the larger process of developing and maintaining programs.
-
-* Menu:
-
-* Compilation:: Compiling programs in languages other than Lisp
- (C, Pascal, etc.)
-* Modes: Lisp Modes. Various modes for editing Lisp programs, with
- different facilities for running the Lisp programs.
-* Libraries: Lisp Libraries. Creating Lisp programs to run in Emacs.
-* Eval: Lisp Eval. Executing a single Lisp expression in Emacs.
-* Debug: Lisp Debug. Debugging Lisp programs running in Emacs.
-* Interaction: Lisp Interaction. Executing Lisp in an Emacs buffer.
-* External Lisp:: Communicating through Emacs with a separate Lisp.
-
-\1f
-File: xemacs.info, Node: Compilation, Next: Lisp Modes, Prev: Running, Up: Running
-
-Running "make", or Compilers Generally
-======================================
-
- Emacs can run compilers for non-interactive languages like C and
-Fortran as inferior processes, feeding the error log into an Emacs
-buffer. It can also parse the error messages and visit the files in
-which errors are found, moving point to the line where the error
-occurred.
-
-`M-x compile'
- Run a compiler asynchronously under Emacs, with error messages to
- `*compilation*' buffer.
-
-`M-x grep'
- Run `grep' asynchronously under Emacs, with matching lines listed
- in the buffer named `*compilation*'.
-
-`M-x kill-compilation'
- Kill the process made by the `M-x compile' command.
-
-`M-x kill-grep'
- Kill the running compilation or `grep' subprocess.
-
-`C-x `'
- Visit the next compiler error message or `grep' match.
-
- To run `make' or another compiler, type `M-x compile'. This command
-reads a shell command line using the minibuffer, then executes the
-specified command line in an inferior shell with output going to the
-buffer named `*compilation*'. By default, the current buffer's default
-directory is used as the working directory for the execution of the
-command; therefore, the makefile comes from this directory.
-
- When the shell command line is read, the minibuffer appears
-containing a default command line (the command you used the last time
-you typed `M-x compile'). If you type just <RET>, the same command
-line is used again. The first `M-x compile' provides `make -k' as the
-default. The default is taken from the variable `compile-command'; if
-the appropriate compilation command for a file is something other than
-`make -k', it can be useful to have the file specify a local value for
-`compile-command' (*note File Variables::.).
-
- When you start a compilation, the buffer `*compilation*' is
-displayed in another window but not selected. Its mode line displays
-the word `run' or `exit' in the parentheses to tell you whether
-compilation is finished. You do not have to keep this buffer visible;
-compilation continues in any case.
-
- To kill the compilation process, type `M-x-kill-compilation'. The
-mode line of the `*compilation*' buffer changes to say `signal' instead
-of `run'. Starting a new compilation also kills any running
-compilation, as only one can occur at any time. Starting a new
-compilation prompts for confirmation before actually killing a
-compilation that is running.
-
- To parse the compiler error messages, type `C-x `' (`next-error').
-The character following `C-x' is the grave accent, not the single
-quote. The command displays the buffer `*compilation*' in one window
-and the buffer in which the next error occurred in another window.
-Point in that buffer is moved to the line where the error was found.
-The corresponding error message is scrolled to the top of the window in
-which `*compilation*' is displayed.
-
- The first time you use `C-x `' after the start of a compilation, it
-parses all the error messages, visits all the files that have error
-messages, and creates markers pointing at the lines the error messages
-refer to. It then moves to the first error message location.
-Subsequent uses of `C-x `' advance down the data set up by the first
-use. When the preparsed error messages are exhausted, the next `C-x `'
-checks for any more error messages that have come in; this is useful if
-you start editing compiler errors while compilation is still going on.
-If no additional error messages have come in, `C-x `' reports an error.
-
- `C-u C-x `' discards the preparsed error message data and parses the
-`*compilation*' buffer again, then displays the first error. This way,
-you can process the same set of errors again.
-
- Instead of running a compiler, you can run `grep' and see the lines
-on which matches were found. To do this, type `M-x grep' with an
-argument line that contains the same arguments you would give to
-`grep': a `grep'-style regexp (usually in single quotes to quote the
-shell's special characters) followed by filenames, which may use
-wildcard characters. The output from `grep' goes in the
-`*compilation*' buffer. You can use `C-x `' to find the lines that
-match as if they were compilation errors.
-
- Note: a shell is used to run the compile command, but the shell is
-not run in interactive mode. In particular, this means that the shell
-starts up with no prompt. If you find your usual shell prompt making an
-unsightly appearance in the `*compilation*' buffer, it means you have
-made a mistake in your shell's initialization file (`.cshrc' or `.shrc'
-or ...) by setting the prompt unconditionally. The shell
-initialization file should set the prompt only if there already is a
-prompt. Here's how to do it in `csh':
-
- if ($?prompt) set prompt = ...
-
-\1f
-File: xemacs.info, Node: Lisp Modes, Next: Lisp Libraries, Prev: Compilation, Up: Running
-
-Major Modes for Lisp
-====================
-
- Emacs has four different major modes for Lisp. They are the same in
-terms of editing commands, but differ in the commands for executing Lisp
-expressions.
-
-Emacs-Lisp mode
- The mode for editing source files of programs to run in Emacs Lisp.
- This mode defines `C-M-x' to evaluate the current defun. *Note
- Lisp Libraries::.
-
-Lisp Interaction mode
- The mode for an interactive session with Emacs Lisp. It defines
- <LFD> to evaluate the sexp before point and insert its value in the
- buffer. *Note Lisp Interaction::.
-
-Lisp mode
- The mode for editing source files of programs that run in other
- dialects of Lisp than Emacs Lisp. This mode defines `C-M-x' to
- send the current defun to an inferior Lisp process. *Note
- External Lisp::.
-
-Inferior Lisp mode
- The mode for an interactive session with an inferior Lisp process.
- This mode combines the special features of Lisp mode and Shell mode
- (*note Shell Mode::.).
-
-Scheme mode
- Like Lisp mode but for Scheme programs.
-
-Inferior Scheme mode
- The mode for an interactive session with an inferior Scheme
- process.
-
-\1f
-File: xemacs.info, Node: Lisp Libraries, Next: Lisp Eval, Prev: Lisp Modes, Up: Running
-
-Libraries of Lisp Code for Emacs
-================================
-
- Lisp code for Emacs editing commands is stored in files whose names
-conventionally end in `.el'. This ending tells Emacs to edit them in
-Emacs-Lisp mode (*note Lisp Modes::.).
-
-* Menu:
-
-* Loading:: Loading libraries of Lisp code into Emacs for use.
-* Compiling Libraries:: Compiling a library makes it load and run faster.
-* Mocklisp:: Converting Mocklisp to Lisp so XEmacs can run it.
-