-This is Info file ../../info/xemacs.info, produced by Makeinfo version
-1.68 from the input file xemacs.texi.
+This is ../info/xemacs.info, produced by makeinfo version 4.0 from
+xemacs/xemacs.texi.
INFO-DIR-SECTION XEmacs Editor
START-INFO-DIR-ENTRY
translation approved by the author instead of in the original English.
\1f
+File: xemacs.info, Node: Basic Indent, Next: Multi-line Indent, Prev: Grinding, Up: Grinding
+
+Basic Program Indentation Commands
+----------------------------------
+
+`<TAB>'
+ Adjust indentation of current line.
+
+`<LFD>'
+ Equivalent to <RET> followed by <TAB> (`newline-and-indent').
+
+ The basic indentation command is <TAB>, which gives the current line
+the correct indentation as determined from the previous lines. The
+function that <TAB> runs depends on the major mode; it is
+`lisp-indent-line' in Lisp mode, `c-indent-line' in C mode, etc. These
+functions understand different syntaxes for different languages, but
+they all do about the same thing. <TAB> in any programming language
+major mode inserts or deletes whitespace at the beginning of the
+current line, independent of where point is in the line. If point is
+inside the whitespace at the beginning of the line, <TAB> leaves it at
+the end of that whitespace; otherwise, <TAB> leaves point fixed with
+respect to the characters around it.
+
+ Use `C-q <TAB>' to insert a tab at point.
+
+ When entering a large amount of new code, use <LFD>
+(`newline-and-indent'), which is equivalent to a <RET> followed by a
+<TAB>. <LFD> creates a blank line, then gives it the appropriate
+indentation.
+
+ <TAB> indents the second and following lines of the body of a
+parenthetical grouping each under the preceding one; therefore, if you
+alter one line's indentation to be nonstandard, the lines below tend to
+follow it. This is the right behavior in cases where the standard
+result of <TAB> does not look good.
+
+ Remember that Emacs assumes that an open-parenthesis, open-brace, or
+other opening delimiter at the left margin (including the indentation
+routines) is the start of a function. You should therefore never have
+an opening delimiter in column zero that is not the beginning of a
+function, not even inside a string. This restriction is vital for
+making the indentation commands fast. *Note Defuns::, for more
+information on this behavior.
+
+\1f
+File: xemacs.info, Node: Multi-line Indent, Next: Lisp Indent, Prev: Basic Indent, Up: Grinding
+
+Indenting Several Lines
+-----------------------
+
+ Several commands are available to re-indent several lines of code
+which have been altered or moved to a different level in a list
+structure.
+
+`C-M-q'
+ Re-indent all the lines within one list (`indent-sexp').
+
+`C-u <TAB>'
+ Shift an entire list rigidly sideways so that its first line is
+ properly indented.
+
+`C-M-\'
+ Re-indent all lines in the region (`indent-region').
+
+ To re-indent the contents of a single list, position point before the
+beginning of it and type `C-M-q'. This key is bound to `indent-sexp' in
+Lisp mode, `indent-c-exp' in C mode, and bound to other suitable
+functions in other modes. The indentation of the line the sexp starts
+on is not changed; therefore, only the relative indentation within the
+list, and not its position, is changed. To correct the position as
+well, type a <TAB> before `C-M-q'.
+
+ If the relative indentation within a list is correct but the
+indentation of its beginning is not, go to the line on which the list
+begins and type `C-u <TAB>'. When you give <TAB> a numeric argument,
+it moves all the lines in the group, starting on the current line,
+sideways the same amount that the current line moves. The command does
+not move lines that start inside strings, or C preprocessor lines when
+in C mode.
+
+ Another way to specify a range to be re-indented is with point and
+mark. The command `C-M-\' (`indent-region') applies <TAB> to every
+line whose first character is between point and mark.
+
+\1f
+File: xemacs.info, Node: Lisp Indent, Next: C Indent, Prev: Multi-line Indent, Up: Grinding
+
+Customizing Lisp Indentation
+----------------------------
+
+ The indentation pattern for a Lisp expression can depend on the
+function called by the expression. For each Lisp function, you can
+choose among several predefined patterns of indentation, or define an
+arbitrary one with a Lisp program.
+
+ The standard pattern of indentation is as follows: the second line
+of the expression is indented under the first argument, if that is on
+the same line as the beginning of the expression; otherwise, the second
+line is indented underneath the function name. Each following line is
+indented under the previous line whose nesting depth is the same.
+
+ If the variable `lisp-indent-offset' is non-`nil', it overrides the
+usual indentation pattern for the second line of an expression, so that
+such lines are always indented `lisp-indent-offset' more columns than
+the containing list.
+
+ Certain functions override the standard pattern. Functions whose
+names start with `def' always indent the second line by
+`lisp-body-indention' extra columns beyond the open-parenthesis
+starting the expression.
+
+ Individual functions can override the standard pattern in various
+ways, according to the `lisp-indent-function' property of the function
+name. (Note: `lisp-indent-function' was formerly called
+`lisp-indent-hook'). There are four possibilities for this property:
+
+`nil'
+ This is the same as no property; the standard indentation pattern
+ is used.
+
+`defun'
+ The pattern used for function names that start with `def' is used
+ for this function also.
+
+a number, NUMBER
+ The first NUMBER arguments of the function are "distinguished"
+ arguments; the rest are considered the "body" of the expression.
+ A line in the expression is indented according to whether the
+ first argument on it is distinguished or not. If the argument is
+ part of the body, the line is indented `lisp-body-indent' more
+ columns than the open-parenthesis starting the containing
+ expression. If the argument is distinguished and is either the
+ first or second argument, it is indented twice that many extra
+ columns. If the argument is distinguished and not the first or
+ second argument, the standard pattern is followed for that line.
+
+a symbol, SYMBOL
+ SYMBOL should be a function name; that function is called to
+ calculate the indentation of a line within this expression. The
+ function receives two arguments:
+ STATE
+ The value returned by `parse-partial-sexp' (a Lisp primitive
+ for indentation and nesting computation) when it parses up to
+ the beginning of this line.
+
+ POS
+ The position at which the line being indented begins.
+
+ It should return either a number, which is the number of columns of
+ indentation for that line, or a list whose first element is such a
+ number. The difference between returning a number and returning a
+ list is that a number says that all following lines at the same
+ nesting level should be indented just like this one; a list says
+ that following lines might call for different indentations. This
+ makes a difference when the indentation is computed by `C-M-q'; if
+ the value is a number, `C-M-q' need not recalculate indentation
+ for the following lines until the end of the list.
+
+\1f
+File: xemacs.info, Node: C Indent, Prev: Lisp Indent, Up: Grinding
+
+Customizing C Indentation
+-------------------------
+
+ Two variables control which commands perform C indentation and when.
+
+ If `c-auto-newline' is non-`nil', newlines are inserted both before
+and after braces that you insert and after colons and semicolons.
+Correct C indentation is done on all the lines that are made this way.
+
+ If `c-tab-always-indent' is non-`nil', the <TAB> command in C mode
+does indentation only if point is at the left margin or within the
+line's indentation. If there is non-whitespace to the left of point,
+<TAB> just inserts a tab character in the buffer. Normally, this
+variable is `nil', and <TAB> always reindents the current line.
+
+ C does not have anything analogous to particular function names for
+which special forms of indentation are desirable. However, it has a
+different need for customization facilities: many different styles of C
+indentation are in common use.
+
+ There are six variables you can set to control the style that Emacs C
+mode will use.
+
+`c-indent-level'
+ Indentation of C statements within surrounding block. The
+ surrounding block's indentation is the indentation of the line on
+ which the open-brace appears.
+
+`c-continued-statement-offset'
+ Extra indentation given to a substatement, such as the then-clause
+ of an `if' or body of a `while'.
+
+`c-brace-offset'
+ Extra indentation for lines that start with an open brace.
+
+`c-brace-imaginary-offset'
+ An open brace following other text is treated as if it were this
+ far to the right of the start of its line.
+
+`c-argdecl-indent'
+ Indentation level of declarations of C function arguments.
+
+`c-label-offset'
+ Extra indentation for a line that is a label, case, or default.
+
+ The variable `c-indent-level' controls the indentation for C
+statements with respect to the surrounding block. In the example:
+
+ {
+ foo ();
+
+the difference in indentation between the lines is `c-indent-level'.
+Its standard value is 2.
+
+ If the open-brace beginning the compound statement is not at the
+beginning of its line, the `c-indent-level' is added to the indentation
+of the line, not the column of the open-brace. For example,
+
+ if (losing) {
+ do_this ();
+
+One popular indentation style is that which results from setting
+`c-indent-level' to 8 and putting open-braces at the end of a line in
+this way. Another popular style prefers to put the open-brace on a
+separate line.
+
+ In fact, the value of the variable `c-brace-imaginary-offset' is
+also added to the indentation of such a statement. Normally this
+variable is zero. Think of this variable as the imaginary position of
+the open brace, relative to the first non-blank character on the line.
+By setting the variable to 4 and `c-indent-level' to 0, you can get
+this style:
+
+ if (x == y) {
+ do_it ();
+ }
+
+ When `c-indent-level' is zero, the statements inside most braces
+line up exactly under the open brace. An exception are braces in column
+zero, like those surrounding a function's body. The statements inside
+those braces are not placed at column zero. Instead, `c-brace-offset'
+and `c-continued-statement-offset' (see below) are added to produce a
+typical offset between brace levels, and the statements are indented
+that far.
+
+ `c-continued-statement-offset' controls the extra indentation for a
+line that starts within a statement (but not within parentheses or
+brackets). These lines are usually statements inside other statements,
+like the then-clauses of `if' statements and the bodies of `while'
+statements. The `c-continued-statement-offset' parameter determines
+the difference in indentation between the two lines in:
+
+ if (x == y)
+ do_it ();
+
+The default value for `c-continued-statement-offset' is 2. Some
+popular indentation styles correspond to a value of zero for
+`c-continued-statement-offset'.
+
+ `c-brace-offset' is the extra indentation given to a line that
+starts with an open-brace. Its standard value is zero; compare:
+
+ if (x == y)
+ {
+
+with:
+
+ if (x == y)
+ do_it ();
+
+If you set `c-brace-offset' to 4, the first example becomes:
+
+ if (x == y)
+ {
+
+ `c-argdecl-indent' controls the indentation of declarations of the
+arguments of a C function. It is absolute: argument declarations
+receive exactly `c-argdecl-indent' spaces. The standard value is 5 and
+results in code like this:
+
+ char *
+ index (string, char)
+ char *string;
+ int char;
+
+ `c-label-offset' is the extra indentation given to a line that
+contains a label, a case statement, or a `default:' statement. Its
+standard value is -2 and results in code like this:
+
+ switch (c)
+ {
+ case 'x':
+
+If `c-label-offset' were zero, the same code would be indented as:
+
+ switch (c)
+ {
+ case 'x':
+
+This example assumes that the other variables above also have their
+default values.
+
+ Using the indentation style produced by the default settings of the
+variables just discussed and putting open braces on separate lines
+produces clear and readable files. For an example, look at any of the C
+source files of XEmacs.
+
+\1f
+File: xemacs.info, Node: Matching, Next: Comments, Prev: Grinding, Up: Programs
+
+Automatic Display of Matching Parentheses
+=========================================
+
+ The Emacs parenthesis-matching feature shows you automatically how
+parentheses match in the text. Whenever a self-inserting character that
+is a closing delimiter is typed, the cursor moves momentarily to the
+location of the matching opening delimiter, provided that is visible on
+the screen. If it is not on the screen, some text starting with that
+opening delimiter is displayed in the echo area. Either way, you see
+the grouping you are closing off.
+
+ In Lisp, automatic matching applies only to parentheses. In C, it
+also applies to braces and brackets. Emacs knows which characters to
+regard as matching delimiters based on the syntax table set by the major
+mode. *Note Syntax::.
+
+ If the opening delimiter and closing delimiter are mismatched--as in
+`[x)'--the echo area displays a warning message. The correct matches
+are specified in the syntax table.
+
+ Two variables control parenthesis matching displays.
+`blink-matching-paren' turns the feature on or off. The default is `t'
+(match display is on); `nil' turns it off.
+`blink-matching-paren-distance' specifies how many characters back
+Emacs searches to find a matching opening delimiter. If the match is
+not found in the specified region, scanning stops, and nothing is
+displayed. This prevents wasting lots of time scanning when there is no
+match. The default is 4000.
+
+\1f
+File: xemacs.info, Node: Comments, Next: Balanced Editing, Prev: Matching, Up: Programs
+
+Manipulating Comments
+=====================
+
+ The comment commands insert, kill and align comments.
+
+`M-;'
+ Insert or align comment (`indent-for-comment').
+
+`C-x ;'
+ Set comment column (`set-comment-column').
+
+`C-u - C-x ;'
+ Kill comment on current line (`kill-comment').
+
+`M-<LFD>'
+ Like <RET> followed by inserting and aligning a comment
+ (`indent-new-comment-line').
+
+ The command that creates a comment is `Meta-;'
+(`indent-for-comment'). If there is no comment already on the line, a
+new comment is created and aligned at a specific column called the
+"comment column". Emacs creates the comment by inserting the string at
+the value of `comment-start'; see below. Point is left after that
+string. If the text of the line extends past the comment column,
+indentation is done to a suitable boundary (usually, at least one space
+is inserted). If the major mode has specified a string to terminate
+comments, that string is inserted after point, to keep the syntax valid.
+
+ You can also use `Meta-;' to align an existing comment. If a line
+already contains the string that starts comments, `M-;' just moves
+point after it and re-indents it to the conventional place. Exception:
+comments starting in column 0 are not moved.
+
+ Some major modes have special rules for indenting certain kinds of
+comments in certain contexts. For example, in Lisp code, comments which
+start with two semicolons are indented as if they were lines of code,
+instead of at the comment column. Comments which start with three
+semicolons are supposed to start at the left margin. Emacs understands
+these conventions by indenting a double-semicolon comment using <TAB>
+and by not changing the indentation of a triple-semicolon comment at
+all.
+
+ ;; This function is just an example.
+ ;;; Here either two or three semicolons are appropriate.
+ (defun foo (x)
+ ;;; And now, the first part of the function:
+ ;; The following line adds one.
+ (1+ x)) ; This line adds one.
+
+ In C code, a comment preceded on its line by nothing but whitespace
+is indented like a line of code.
+
+ Even when an existing comment is properly aligned, `M-;' is still
+useful for moving directly to the start of the comment.
+
+ `C-u - C-x ;' (`kill-comment') kills the comment on the current
+line, if there is one. The indentation before the start of the comment
+is killed as well. If there does not appear to be a comment in the
+line, nothing happens. To reinsert the comment on another line, move
+to the end of that line, type first `C-y', and then `M-;' to realign
+the comment. Note that `C-u - C-x ;' is not a distinct key; it is `C-x
+;' (`set-comment-column') with a negative argument. That command is
+programmed to call `kill-comment' when called with a negative argument.
+However, `kill-comment' is a valid command which you could bind
+directly to a key if you wanted to.
+
+Multiple Lines of Comments
+--------------------------
+
+ If you are typing a comment and want to continue it on another line,
+use the command `Meta-<LFD>' (`indent-new-comment-line'), which
+terminates the comment you are typing, creates a new blank line
+afterward, and begins a new comment indented under the old one. If
+Auto Fill mode is on and you go past the fill column while typing, the
+comment is continued in just this fashion. If point is not at the end
+of the line when you type `M-<LFD>', the text on the rest of the line
+becomes part of the new comment line.
+
+Options Controlling Comments
+----------------------------
+
+ The comment column is stored in the variable `comment-column'. You
+can explicitly set it to a number. Alternatively, the command `C-x ;'
+(`set-comment-column') sets the comment column to the column point is
+at. `C-u C-x ;' sets the comment column to match the last comment
+before point in the buffer, and then calls `Meta-;' to align the
+current line's comment under the previous one. Note that `C-u - C-x ;'
+runs the function `kill-comment' as described above.
+
+ `comment-column' is a per-buffer variable; altering the variable
+affects only the current buffer. You can also change the default value.
+*Note Locals::. Many major modes initialize this variable for the
+current buffer.
+
+ The comment commands recognize comments based on the regular
+expression that is the value of the variable `comment-start-skip'.
+This regexp should not match the null string. It may match more than
+the comment starting delimiter in the strictest sense of the word; for
+example, in C mode the value of the variable is `"/\\*+ *"', which
+matches extra stars and spaces after the `/*' itself. (Note that `\\'
+is needed in Lisp syntax to include a `\' in the string, which is needed
+to deny the first star its special meaning in regexp syntax. *Note
+Regexps::.)
+
+ When a comment command makes a new comment, it inserts the value of
+`comment-start' to begin it. The value of `comment-end' is inserted
+after point and will follow the text you will insert into the comment.
+In C mode, `comment-start' has the value `"/* "' and `comment-end' has
+the value `" */"'.
+
+ `comment-multi-line' controls how `M-<LFD>'
+(`indent-new-comment-line') behaves when used inside a comment. If
+`comment-multi-line' is `nil', as it normally is, then `M-<LFD>'
+terminates the comment on the starting line and starts a new comment on
+the new following line. If `comment-multi-line' is not `nil', then
+`M-<LFD>' sets up the new following line as part of the same comment
+that was found on the starting line. This is done by not inserting a
+terminator on the old line and not inserting a starter on the new line.
+In languages where multi-line comments are legal, the value you choose
+for this variable is a matter of taste.
+
+ The variable `comment-indent-hook' should contain a function that is
+called to compute the indentation for a newly inserted comment or for
+aligning an existing comment. Major modes set this variable
+differently. The function is called with no arguments, but with point
+at the beginning of the comment, or at the end of a line if a new
+comment is to be inserted. The function should return the column in
+which the comment ought to start. For example, in Lisp mode, the
+indent hook function bases its decision on the number of semicolons
+that begin an existing comment and on the code in the preceding lines.
+
+\1f
+File: xemacs.info, Node: Balanced Editing, Next: Lisp Completion, Prev: Comments, Up: Programs
+
+Editing Without Unbalanced Parentheses
+======================================
+
+`M-('
+ Put parentheses around next sexp(s) (`insert-parentheses').
+
+`M-)'
+ Move past next close parenthesis and re-indent
+ (`move-over-close-and-reindent').
+
+ The commands `M-(' (`insert-parentheses') and `M-)'
+(`move-over-close-and-reindent') are designed to facilitate a style of
+editing which keeps parentheses balanced at all times. `M-(' inserts a
+pair of parentheses, either together as in `()', or, if given an
+argument, around the next several sexps, and leaves point after the open
+parenthesis. Instead of typing `( F O O )', you can type `M-( F O O',
+which has the same effect except for leaving the cursor before the
+close parenthesis. You can then type `M-)', which moves past the close
+parenthesis, deletes any indentation preceding it (in this example
+there is none), and indents with <LFD> after it.
+
+\1f
+File: xemacs.info, Node: Lisp Completion, Next: Documentation, Prev: Balanced Editing, Up: Programs
+
+Completion for Lisp Symbols
+===========================
+
+ Completion usually happens in the minibuffer. An exception is
+completion for Lisp symbol names, which is available in all buffers.
+
+ The command `M-<TAB>' (`lisp-complete-symbol') takes the partial
+Lisp symbol before point to be an abbreviation, and compares it against
+all non-trivial Lisp symbols currently known to Emacs. Any additional
+characters that they all have in common are inserted at point.
+Non-trivial symbols are those that have function definitions, values, or
+properties.
+
+ If there is an open-parenthesis immediately before the beginning of
+the partial symbol, only symbols with function definitions are
+considered as completions.
+
+ If the partial name in the buffer has more than one possible
+completion and they have no additional characters in common, a list of
+all possible completions is displayed in another window.
+
+\1f
+File: xemacs.info, Node: Documentation, Next: Change Log, Prev: Lisp Completion, Up: Programs
+
+Documentation Commands
+======================
+
+ As you edit Lisp code to be run in Emacs, you can use the commands
+`C-h f' (`describe-function') and `C-h v' (`describe-variable') to
+print documentation of functions and variables you want to call. These
+commands use the minibuffer to read the name of a function or variable
+to document, and display the documentation in a window.
+
+ For extra convenience, these commands provide default arguments
+based on the code in the neighborhood of point. `C-h f' sets the
+default to the function called in the innermost list containing point.
+`C-h v' uses the symbol name around or adjacent to point as its default.
+
+ The `M-x manual-entry' command gives you access to documentation on
+Unix commands, system calls, and libraries. The command reads a topic
+as an argument, and displays the Unix manual page for that topic.
+`manual-entry' always searches all 8 sections of the manual and
+concatenates all the entries it finds. For example, the topic
+`termcap' finds the description of the termcap library from section 3,
+followed by the description of the termcap data base from section 5.
+
+\1f
File: xemacs.info, Node: Change Log, Next: Tags, Prev: Documentation, Up: Programs
Change Logs
names and positions of the functions (or other named subunits) in each
file. Grouping the related files makes it possible to search or replace
through all the files with one command. Recording the function names
-and positions makes possible the `M-.' command which finds the
+and positions makes possible the `M-.' command which finds the
definition of a function by looking up which of the files it is in.
Tags tables are stored in files called "tags table files". The
* Tag Syntax:: Tag syntax for various types of code and text files.
* Create Tags Table:: Creating a tags table with `etags'.
+* Etags Regexps:: Create arbitrary tags using regular expressions.
* Select Tags Table:: How to visit a tags table.
* Find Tag:: Commands to find the definition of a specific tag.
* Tags Search:: Using a tags table for searching and replacing.
* List Tags:: Listing and finding tags defined in a file.
\1f
-File: xemacs.info, Node: Tag Syntax, Next: Create Tags Table, Up: Tags
+File: xemacs.info, Node: Tag Syntax, Next: Create Tags Table, Prev: Tags, Up: Tags
Source File Tag Syntax
----------------------
Here is how tag syntax is defined for the most popular languages:
* In C code, any C function or typedef is a tag, and so are
- definitions of `struct', `union' and `enum'. `#define' macro
- definitions and `enum' constants are also tags, unless you specify
- `--no-defines' when making the tags table. Similarly, global
- variables are tags, unless you specify `--no-globals'. Use of
- `--no-globals' and `--no-defines' can make the tags table file
- much smaller.
+ definitions of `struct', `union' and `enum'. You can tag function
+ declarations and external variables in addition to function
+ definitions by giving the `--declarations' option to `etags'.
+ `#define' macro definitions and `enum' constants are also tags,
+ unless you specify `--no-defines' when making the tags table.
+ Similarly, global variables are tags, unless you specify
+ `--no-globals'. Use of `--no-globals' and `--no-defines' can make
+ the tags table file much smaller.
* In C++ code, in addition to all the tag constructs of C code,
member functions are also recognized, and optionally member
variables if you use the `--members' option. Tags for variables
and functions in classes are named `CLASS::VARIABLE' and
- `CLASS::FUNCTION'.
+ `CLASS::FUNCTION'. `operator' functions tags are named, for
+ example `operator+'.
* In Java code, tags include all the constructs recognized in C++,
- plus the `extends' and `implements' constructs. Tags for variables
- and functions in classes are named `CLASS.VARIABLE' and
- `CLASS.FUNCTION'.
+ plus the `interface', `extends' and `implements' constructs. Tags
+ for variables and functions in classes are named `CLASS.VARIABLE'
+ and `CLASS.FUNCTION'.
* In LaTeX text, the argument of any of the commands `\chapter',
`\section', `\subsection', `\subsubsection', `\eqno', `\label',
Other commands can make tags as well, if you specify them in the
environment variable `TEXTAGS' before invoking `etags'. The value
of this environment variable should be a colon-separated list of
- commands names. For example,
+ command names. For example,
TEXTAGS="def:newcommand:newenvironment"
export TEXTAGS
Several other languages are also supported:
+ * In Ada code, functions, procedures, packages, tasks, and types are
+ tags. Use the `--packages-only' option to create tags for packages
+ only.
+
* In assembler code, labels appearing at the beginning of a line,
followed by a colon, are tags.
nonterminal it constructs. The portions of the file that contain
C code are parsed as C code.
- * In Cobol code, paragraphs names are the tags, i.e. any word
- starting in column 8 and followed by a full stop.
+ * In Cobol code, tags are paragraph names; that is, any word
+ starting in column 8 and followed by a period.
* In Erlang code, the tags are the functions, records, and macros
defined in the file.
- * In Fortran code, functions and subroutines are tags.
+ * In Fortran code, functions, subroutines and blockdata are tags.
* In Objective C code, tags include Objective C definitions for
- classes, class categories, methods and protocols.
+ classes, class categories, methods, and protocols.
* In Pascal code, the tags are the functions and procedures defined
in the file.
- * In Perl code, the tags are the procedures defined by the `sub'
- keyword.
+ * In Perl code, the tags are the procedures defined by the `sub',
+ `my' and `local' keywords. Use `--globals' if you want to tag
+ global variables.
* In Postscript code, the tags are the functions.
* In Prolog code, a tag name appears at the left margin.
- You can also generate tags based on regexp matching (*note Create
-Tags Table::.) to handle other formats and languages.
+ * In Python code, `def' or `class' at the beginning of a line
+ generate a tag.
+
+ You can also generate tags based on regexp matching (*note Etags
+Regexps::) to handle other formats and languages.
\1f
-File: xemacs.info, Node: Create Tags Table, Next: Select Tags Table, Prev: Tag Syntax, Up: Tags
+File: xemacs.info, Node: Create Tags Table, Next: Etags Regexps, Prev: Tag Syntax, Up: Tags
Creating Tags Tables
--------------------
etags INPUTFILES...
The `etags' program reads the specified files, and writes a tags table
-named `TAGS' in the current working directory. `etags' recognizes the
-language used in an input file based on its file name and contents.
-You can specify the language with the `--language=NAME' option,
-described below.
+named `TAGS' in the current working directory. You can intermix
+compressed and plain text source file names. `etags' knows about the
+most common compression formats, and does the right thing. So you can
+compress all your source files and have `etags' look for compressed
+versions of its file name arguments, if it does not find uncompressed
+versions. Under MS-DOS, `etags' also looks for file names like
+`mycode.cgz' if it is given `mycode.c' on the command line and
+`mycode.c' does not exist.
+
+ `etags' recognizes the language used in an input file based on its
+file name and contents. You can specify the language with the
+`--language=NAME' option, described below.
If the tags table data become outdated due to changes in the files
described in the table, the way to update the tags table is the same
tags file will contain absolute file names. This way, the tags file
will still refer to the same files even if you move it, as long as the
source files remain in the same place. Absolute file names start with
-`/', or with `DEVICE:/' on MS-DOS and Windows.
+`/', or with `DEVICE:/' on MS-DOS and MS-Windows.
When you want to make a tags table from a great number of files, you
may have problems listing them on the command line, because some systems
`etags' to resume guessing the language from the file names and file
contents. Specify `--language=none' to turn off language-specific
processing entirely; then `etags' recognizes tags by regexp matching
-alone. `etags --help' prints the list of the languages `etags' knows,
-and the file name rules for guessing the language.
+alone (*note Etags Regexps::).
+
+ `etags --help' prints the list of the languages `etags' knows, and
+the file name rules for guessing the language. It also prints a list of
+all the available `etags' options, together with a short explanation.
+
+\1f
+File: xemacs.info, Node: Etags Regexps, Next: Select Tags Table, Prev: Create Tags Table, Up: Tags
+
+Etags Regexps
+-------------
The `--regex' option provides a general way of recognizing tags
based on regexp matching. You can freely intermix it with file names.
You should not match more characters with TAGREGEXP than that needed
to recognize what you want to tag. If the match is such that more
-characters than needed are unavoidably matched by TAGREGEXP, you may
-find useful to add a NAMEREGEXP, in order to narrow the tag scope. You
-can find some examples below.
+characters than needed are unavoidably matched by TAGREGEXP (as will
+usually be the case), you should add a NAMEREGEXP, to pick out just the
+tag. This will enable Emacs to find tags more accurately and to do
+completion on tag names more reliably. You can find some examples
+below.
+
+ The option `--ignore-case-regex' (or `-c') is like `--regex', except
+that the regular expression provided will be matched without regard to
+case, which is appropriate for various programming languages.
The `-R' option deletes all the regexps defined with `--regex'
options. It applies to the file names following it, as you can see
additional tags in `bar.ber'. `etags' uses the Lisp tags rules, and no
regexp matching, to recognize tags in `los.er'.
+ A regular expression can be bound to a given language, by prepending
+it with `{lang}'. When you do this, `etags' will use the regular
+expression only for files of that language. `etags --help' prints the
+list of languages recognised by `etags'. The following example tags
+the `DEFVAR' macros in the Emacs source files. `etags' applies this
+regular expression to C files only:
+
+ --regex='{c}/[ \t]*DEFVAR_[A-Z_ \t(]+"\([^"]+\)"/'
+
+This feature is particularly useful when storing a list of regular
+expressions in a file. The following option syntax instructs `etags'
+to read two files of regular expressions. The regular expressions
+contained in the second file are matched without regard to case.
+
+ --regex=@first-file --ignore-case-regex=@second-file
+
+A regex file contains one regular expressions per line. Empty lines,
+and lines beginning with space or tab are ignored. When the first
+character in a line is `@', `etags' assumes that the rest of the line
+is the name of a file of regular expressions. This means that such
+files can be nested. All the other lines are taken to be regular
+expressions. For example, one can create a file called `emacs.tags'
+with the following contents (the first line in the file is a comment):
+
+ -- This is for GNU Emacs source files
+ {c}/[ \t]*DEFVAR_[A-Z_ \t(]+"\([^"]+\)"/\1/
+
+and then use it like this:
+
+ etags --regex=@emacs.tags *.[ch] */*.[ch]
+
Here are some more examples. The regexps are quoted to protect them
from shell interpretation.
-Tag the `DEFVAR' macros in the emacs source files:
+ * Tag Octave files:
- --regex='/[ \t]*DEFVAR_[A-Z_ \t(]+"\([^"]+\)"/'
+ etags --language=none \
+ --regex='/[ \t]*function.*=[ \t]*\([^ \t]*\)[ \t]*(/\1/' \
+ --regex='/###key \(.*\)/\1/' \
+ --regex='/[ \t]*global[ \t].*/' \
+ *.m
-Tag VHDL files (this example is a single long line, broken here for
-formatting reasons):
+ Note that tags are not generated for scripts so that you have to
+ add a line by yourself of the form `###key <script-name>' if you
+ want to jump to it.
- --language=none
- --regex='/[ \t]*\(ARCHITECTURE\|CONFIGURATION\) +[^ ]* +OF/'
- --regex='/[ \t]*\(ATTRIBUTE\|ENTITY\|FUNCTION\|PACKAGE\
- \( BODY\)?\|PROCEDURE\|PROCESS\|TYPE\)[ \t]+\([^ \t(]+\)/\3/'
+ * Tag Tcl files:
-Tag TCL files (this last example shows the usage of a NAMEREGEXP):
+ etags --language=none --regex='/proc[ \t]+\([^ \t]+\)/\1/' *.tcl
- --lang=none --regex='/proc[ \t]+\([^ \t]+\)/\1/'
+ * Tag VHDL files:
- For a list of the other available `etags' options, execute `etags
---help'.
+ --language=none \
+ --regex='/[ \t]*\(ARCHITECTURE\|CONFIGURATION\) +[^ ]* +OF/' \
+ --regex='/[ \t]*\(ATTRIBUTE\|ENTITY\|FUNCTION\|PACKAGE\
+ \( BODY\)?\|PROCEDURE\|PROCESS\|TYPE\)[ \t]+\([^ \t(]+\)/\3/'
\1f
-File: xemacs.info, Node: Select Tags Table, Next: Find Tag, Prev: Create Tags Table, Up: Tags
+File: xemacs.info, Node: Select Tags Table, Next: Find Tag, Prev: Etags Regexps, Up: Tags
Selecting a Tags Table
----------------------
For example:
(setq tag-table-alist
- '(("/usr/src/public/perl/" . "/usr/src/public/perl/perl-3.0/")
- ("\\.el$" . "/usr/local/emacs/src/")
- ("/jbw/gnu/" . "/usr15/degree/stud/jbw/gnu/")
- ("" . "/usr/local/emacs/src/")
- ))
+ '(("/usr/src/public/perl/" . "/usr/src/public/perl/perl-3.0/")
+ ("\\.el$" . "/usr/local/emacs/src/")
+ ("/jbw/gnu/" . "/usr15/degree/stud/jbw/gnu/")
+ ("" . "/usr/local/emacs/src/")
+ ))
The example defines the tags table alist in the following way:
and then using `M-.' you can quickly look at the source of any Emacs
function.
-\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.
-
projects / chise / xemacs-chise.git / blobdiff