Many programming-language modes have traditionally assumed that any opening parenthesis or brace found at the left margin is the start of a top-level definition, or defun. So, by default, commands which seek the beginning of a defun accept such a delimiter as signifying that position. If you want to override this convention, you can do so by setting the user option open-paren-in-column-0-is-defun-start to nil. If this option is set to t (the default), commands seeking the start of a defun will stop at opening parentheses or braces at column zero which aren't in a comment or string. When it is nil, defuns are found by searching for parens or braces at the outermost level. Since low-level Emacs routines no longer depend on this convention, you usually won't need to change open-paren-in-column-0-is-defun-start from its default.

These commands move point or set up the region based on top-level major definitions, also called defuns.

C-M-a

Move to beginning of current or preceding defun (beginning-of-defun).

C-M-e

Move to end of current or following defun (end-of-defun).

C-M-h

Put region around whole current or following defun (mark-defun).

The commands to move to the beginning and end of the current defun are C-M-a (beginning-of-defun) and C-M-e (end-of-defun). If you repeat one of these commands, or use a positive numeric argument, each repetition moves to the next defun in the direction of motion. C-M-a with a negative argument -n moves forward n times to the next beginning of a defun. This is not exactly the same place that C-M-e with argument n would move to; the end of this defun is not usually exactly the same place as the beginning of the following defun. (Whitespace, comments, and perhaps declarations can separate them.) Likewise, C-M-e with a negative argument moves back to an end of a defun, which is not quite the same as C-M-a with a positive argument. To operate on the current defun, use C-M-h (mark-defun), which sets the mark at the end of the current defun and puts point at its beginning. Marking Objects. This is the easiest way to get ready to kill the defun in order to move it to a different place in the file. If the defun is directly preceded by comments (with no intervening blank lines), they are marked, too. If you use the command while point is between defuns, it uses the following defun. If you use the command while the mark is already active, it extends the end of the region to include one more defun. With a prefix argument, it marks that many defuns or extends the region by the appropriate number of defuns. With negative prefix argument it marks defuns in the opposite direction and also changes the direction of selecting for subsequent uses of mark-defun. In C mode, C-M-h runs the function c-mark-function, which is almost the same as mark-defun; the difference is that it backs up over the argument declarations, function name and returned data type so that the entire C function is inside the region. This is an example of how major modes adjust the standard key bindings so that they do their standard jobs in a way better fitting a particular language. Other major modes may replace any or all of these key bindings for that purpose. Some programming languages supported nested defuns, whereby a defun (such as a function or a method or a class) can be defined inside (i.e., as part of the body) of another defun. The commands described above by default find the beginning and the end of the innermost defun around point. Major modes based on the tree-sitter library provide control of this behavior: by default, the value of treesit-defun-tactic is set to nested; if it's set to=top-level=, the defun commands will find the outermost defuns instead; if the value is set to parent-first, the defun command always tries to move out of the current enclosing defun rather than moving to the previous or next defun around point; if there's no enclosing defun, it moves to the previous or next defun.

These commands move point or set up the region based on units of code, also called sentences. Even though sentences are usually considered when writing human languages, Emacs can use the same commands to move over certain constructs in programming languages (Sentences, Moving by Defuns). In a programming language a sentence is usually a complete language construct smaller than defuns, but larger than sexps (List Motion). What exactly is a sentence in this case depends on the programming language, but usually it is a complete statement, such as a variable definition and initialization, or a conditional statement. An example of a sentence in the C language could be

int x = 5;

or in the JavaScript language it could look like

const thing = () => console.log("Hi");
const foo = [1] == '1'
  ? "No way"
  : "...";

M-a

Move to beginning of current or preceding sentence (backward-sentence).

M-e

Move to end of current or following sentence (forward-sentence).

The commands to move to the beginning and end of the current sentence are M-a (backward-sentence) and M-e (forward-sentence). If you repeat one of these commands, or use a positive numeric argument, each repetition moves to the next sentence in the direction of motion. M-a with a negative argument -n moves forward n times to the next end of a sentence. Likewise, M-e with a negative argument moves back to the start of a sentence.

The Imenu facility offers a way to find the major definitions in a file by name. It is useful both in programming-language major modes, where the definitions are variables, functions, etc., and in text formatter major modes, where it treats each chapter, section, etc., as a definition. (Xref, for a more powerful feature that handles multiple files together.) If you type M-g i (imenu), it reads the name of a definition using the minibuffer, then moves point to that definition. You can use completion to specify the name; the command displays the list of matching valid names in the completions buffer. If the index is hierarchical, then by default the completion candidates are also shown hierarchically, as a nested list: first you need to choose a section, then a subsection, etc., and finally the name of the definition. However, if you set imenu-flatten to a non-nil value, then instead of the nested menu you can select a completion candidate from a flattened list of definitions. How the sections and subsections are shown in the flattened list of completion candidates depends on the value of imenu-flatten, which can be one of the following:

prefix

This shows each candidate prefixed by names of its section, subsection, subsubsection, etc., with each level separated from the next by the string that is the value of imenu-level-separator, by default :.

annotation

This shows the section names as annotations, following each definition name.

group

This shows the completion candidates grouped by their sections.

Alternatively, you can bind the command imenu to a mouse click. Then it displays mouse menus for you to select a definition name. You can also add the buffer's index to the menu bar by calling imenu-add-menubar-index. If you want to have this menu bar item available for all buffers in a certain major mode, you can do this by adding imenu-add-menubar-index to its mode hook. But if you have done that, you will have to wait a little while each time you visit a file in that mode, while Emacs finds all the definitions in that buffer. When you change the contents of a buffer, if you add or delete definitions, you can update the buffer's index based on the new contents by invoking the *Rescan* item in the menu. Rescanning happens automatically if you set imenu-auto-rescan to a non-nil value. There is no need to rescan because of small changes in the text. imenu-auto-rescan will be disabled in buffers that are larger than imenu-auto-rescan-maxout in bytes, and scanning is stopped if it takes more than imenu-max-index-time seconds. You can customize the way the menus are sorted by setting the variable imenu-sort-function. By default, names are ordered as they occur in the buffer; if you want alphabetic sorting, use the symbol imenu--sort-by-name as the value. You can also define your own comparison function by writing Lisp code. You can also customize how Imenu completions are sorted by changing the variable completion-category-overrides and setting its display-sort-function for the category imenu. If Eglot is activated for the current buffer's project (Projects) and the current buffer's major mode, Eglot provides its own facility for producing the buffer's index based on the analysis of the program source by the language-server which manages the current buffer. Eglot Features. Imenu provides the information to guide Which Function mode (Which Function). The Speedbar can also use it (Speedbar).

Which Function mode is a global minor mode (Minor Modes) which displays the current function name in the mode line or header line, updating it as you move around in a buffer. To either enable or disable Which Function mode, use the command M-x which-function-mode. Which Function mode is a global minor mode. By default, it takes effect in all major modes that know how to support it (i.e., all the major modes that support Imenu). You can restrict it to a specific list of major modes by changing the value of the variable which-func-modes from t (which means to support all available major modes) to a list of major mode names. By default, Which Function mode displays the current function name using the mode line. Customize which-func-display to header, mode, or mode-and-header to use the header line, mode line, or both, respectively.

TAB

Adjust indentation of current line (indent-for-tab-command).

RET

Insert a newline, then adjust indentation of following line (newline).

The basic indentation command is TAB (indent-for-tab-command), which was documented in Indentation. In programming language modes, TAB indents the current line, based on the indentation and syntactic content of the preceding lines; if the region is active, TAB indents each line within the region, not just the current line. The command RET (newline), which was documented in Inserting Text, does the same as C-j followed by TAB: it inserts a new line, then adjusts the line's indentation. When indenting a line that starts within a parenthetical grouping, Emacs usually places the start of the line under the preceding line within the group, or under the text after the parenthesis. If you manually give one of these lines a nonstandard indentation (e.g., for aesthetic purposes), the lines below will follow it. The indentation commands for most programming language modes assume that an open-parenthesis, open-brace or other opening delimiter at the left margin is the start of a function. If the code you are editing violates this assumption—even if the delimiters occur in strings or comments—you must set open-paren-in-column-0-is-defun-start to nil for indentation to work properly. Left Margin Paren.

Sometimes, you may want to reindent several lines of code at a time. One way to do this is to use the mark; when the mark is active and the region is non-empty, TAB indents every line in the region. Alternatively, the command C-M-\ (indent-region) indents every line in the region, whether or not the mark is active (Indentation Commands). In addition, Emacs provides the following commands for indenting large chunks of code:

C-M-q

Reindent all the lines within one parenthetical grouping.

M-q

Fill a single paragraph in a defun, or reindent all the lines within that defun.

C-u TAB

Shift an entire parenthetical grouping rigidly sideways so that its first line is properly indented.

M-x indent-code-rigidly

Shift all the lines in the region rigidly sideways, but do not alter lines that start inside comments and strings.

To reindent the contents of a single parenthetical grouping, position point before the beginning of the grouping and type C-M-q. This changes the relative indentation within the grouping, without affecting its overall indentation (i.e., the indentation of the line where the grouping starts). The function that C-M-q runs depends on the major mode; it is indent-pp-sexp in Lisp mode, c-indent-exp in C mode, etc. To correct the overall indentation as well, type TAB first. To reindent the entire defun around point, type M-q (prog-fill-reindent-defun). If point is in a comment or a string, this command fills and indents the comment or string instead. What exactly constitutes a comment, a string, or a defun depends on the major mode: the bounds of a defun are decided by the variables beginning-of-defun-function and end-of-defun-function (List Motion), and the filling mechanism is decided by fill-paragraph-function (Filling). If you like the relative indentation within a grouping but not the indentation of its first line, move point to that first line and type C-u TAB. In Lisp, C, and some other major modes, TAB with a numeric argument reindents the current line as usual, then reindents by the same amount all the lines in the parenthetical grouping starting on the current line. It is clever, though, and does not alter lines that start inside strings. Neither does it alter C preprocessor lines when in C mode, but it does reindent any continuation lines that may be attached to them. The command M-x indent-code-rigidly rigidly shifts all the lines in the region sideways, like indent-rigidly does (Indentation Commands). It doesn't alter the indentation of lines that start inside a string, unless the region also starts inside that string. The prefix arg specifies the number of columns to indent.

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 treat the second lines as the start of a body, by indenting the second line lisp-body-indent additional columns beyond the open-parenthesis that starts the expression. You can override the standard pattern in various ways for individual functions, according to the lisp-indent-function property of the function name. This is normally done for macro definitions, using the declare construct. Defining Macros. In Emacs Lisp, lists are usually indented as if they are function-like forms:

(setq foo '(bar zot
                gazonk))

However, if you add a space after the opening parenthesis, this tells Emacs that it's a data list instead of a piece of code, and Emacs will then indent it like this:

(setq foo '( bar zot
             gazonk))

Here are special features for indentation in C mode and related modes:

C-c C-q

Reindent the current top-level function definition or aggregate type declaration (c-indent-defun in CC mode, c-ts-mode-indent-defun in c-ts-mode based on tree-sitter).

C-M-q

Reindent each line in the balanced expression (Expressions), also known as "sexp", that follows point. In CC mode, this invokes c-indent-exp; in tree-sitter based c-ts-mode this invokes a more general prog-indent-sexp. A prefix argument inhibits warning messages about invalid syntax.

TAB

Reindent the current line, active region, or block starting on this line (c-indent-line-or-region). With prefix argument, rigidly reindent the balanced expression which starts on the current line, if the current line needs reindentation. If c-tab-always-indent is t, this command always reindents the current line and does nothing else. This is the default. If that variable is nil, this command reindents the current line only if point is at the left margin or in the line's indentation; otherwise, it inserts a tab (or the equivalent number of spaces, if indent-tabs-mode is nil). Any other value (not nil or t) means always reindent the line, and also insert a tab if within a comment or a string.

To reindent the whole current buffer, type C-x h C-M-\. This first selects the whole buffer as the region, then reindents that region. To reindent the current block, use C-M-u C-M-q. This moves to the front of the block and then reindents it all.

C mode and related modes use a flexible mechanism for customizing indentation. C mode indents a source line in two steps: first it classifies the line syntactically according to its contents and context; second, it determines the indentation offset associated by your selected style with the syntactic construct and adds this onto the indentation of the anchor statement.

C-c . style RET

Select a predefined style style (c-set-style in CC mode, c-ts-mode-set-style in c-ts-mode based on tree-sitter).

A style is a named collection of customizations that can be used in C mode and the related modes. Styles, for a complete description. Emacs comes with several predefined styles, including gnu, k&r, bsd, stroustrup, linux, python, java, whitesmith, ellemtel, and awk. Some of these styles are primarily intended for one language, but any of them can be used with any of the languages supported by these modes. To find out what a style looks like, select it and reindent some code, e.g., by typing C-M-q at the start of a function definition. To choose a style for the current buffer, use the command C-c .. Specify a style name as an argument (case is not significant). This command affects the current buffer only, and it affects only future invocations of the indentation commands; it does not reindent the code already in the buffer. To reindent the whole buffer in the new style, you can type C-x h C-M-\. When using CC mode, you can also set the variable c-default-style to specify the default style for various major modes. Its value should be either the style's name (a string) or an alist, in which each element specifies one major mode and which indentation style to use for it. For example,

(setq c-default-style
      '((java-mode . "java")
        (awk-mode . "awk")
        (other . "gnu")))

specifies explicit choices for Java and AWK modes, and the default gnu style for the other C-like modes. (These settings are actually the defaults.) This variable takes effect when you select one of the C-like major modes; thus, if you specify a new default style for Java mode, you can make it take effect in an existing Java mode buffer by typing M-x java-mode there. When using the tree-sitter based c-ts-mode, you can set the default indentation style by customizing the variable c-ts-mode-indent-style. The gnu style specifies the formatting recommended by the GNU Project for C; it is the default, so as to encourage use of our recommended style. Indentation Engine Basics, and Customizing Indentation, for more information on customizing indentation for C and related modes, including how to override parts of an existing style and how to define your own styles. As an alternative to specifying a style, you can tell Emacs to guess a style by typing M-x c-guess in a sample code buffer. You can then apply the guessed style to other buffers with M-x c-guess-install. Guessing the Style, for details.

Each programming language mode has its own definition of a balanced expression. Balanced expressions typically include individual symbols, numbers, and string constants, as well as pieces of code enclosed in a matching pair of delimiters. The following commands deal with balanced expressions (in Emacs, such expressions are referred to internally as /sexps/(The word "sexp" is used to refer to an expression in Lisp.)).

C-M-f

Move forward over a balanced expression (forward-sexp).

C-M-b

Move backward over a balanced expression (backward-sexp).

C-M-k

Kill balanced expression forward (kill-sexp).

C-M-t

Transpose expressions (transpose-sexps).

C-M-@@, C-M-SPC

Put mark after following expression (mark-sexp).

To move forward over a balanced expression, use C-M-f (forward-sexp). If the first significant character after point is an opening delimiter (e.g., (, [ or @samp{@{} in C), this command moves past the matching closing delimiter. If the character begins a symbol, string, or number, the command moves over that. The command C-M-b (backward-sexp) moves backward over a balanced expression—like C-M-f, but in the reverse direction. If the expression is preceded by any prefix characters (single-quote, backquote and comma, in Lisp), the command moves back over them as well. C-M-f or C-M-b with an argument repeats that operation the specified number of times; with a negative argument means to move in the opposite direction. In most modes, these two commands move across comments as if they were whitespace. Note that their keys, C-M-f and C-M-b, are analogous to C-f and C-b, which move by characters (Moving Point), and M-f and M-b, which move by words (Words). To kill a whole balanced expression, type C-M-k (kill-sexp). This kills the text that C-M-f would move over. C-M-t (transpose-sexps) switches the positions of the previous balanced expression and the next one. It is analogous to the C-t command, which transposes characters (Transpose). An argument to C-M-t serves as a repeat count, moving the previous expression over that many following ones. A negative argument moves the previous balanced expression backwards across those before it. An argument of zero, rather than doing nothing, transposes the balanced expressions ending at or after point and the mark. To operate on balanced expressions with a command which acts on the region, type C-M-SPC (mark-sexp). This sets the mark where C-M-f would move to. While the mark is active, each successive call to this command extends the region by shifting the mark by one expression. Positive or negative numeric arguments move the mark forward or backward by the specified number of expressions. The alias C-M-@@ is equivalent to C-M-SPC. Marking Objects, for more information about this and related commands. In languages that use infix operators, such as C, it is not possible to recognize all balanced expressions because there can be multiple possibilities at a given position. For example, C mode does not treat foo + bar as a single expression, even though it is one C expression; instead, it recognizes foo as one expression and bar as another, with the + as punctuation between them. However, C mode recognizes (foo + bar) as a single expression, because of the parentheses.

The following commands move over groupings delimited by parentheses (or whatever else serves as delimiters in the language you are working with). They ignore strings and comments, including any parentheses within them, and also ignore parentheses that are quoted with an escape character. These commands are mainly intended for editing programs, but can be useful for editing any text containing parentheses. They are referred to internally as "list commands" because in Lisp these groupings are lists. These commands assume that the starting point is not inside a string or a comment. If you invoke them from inside a string or comment, the results are unreliable.

C-M-n

Move forward over a parenthetical group (forward-list).

C-M-p

Move backward over a parenthetical group (backward-list).

C-M-u

Move up in parenthesis structure (backward-up-list).

C-M-d

Move down in parenthesis structure (down-list).

The list commands C-M-n (forward-list) and C-M-p (backward-list) move forward or backward over one (or n) parenthetical groupings. C-M-n and C-M-p try to stay at the same level in the parenthesis structure. To move up one (or n) levels, use C-M-u (backward-up-list). C-M-u moves backward up past one unmatched opening delimiter. A positive argument serves as a repeat count; a negative argument reverses the direction of motion, so that the command moves forward and up one or more levels. To move down in the parenthesis structure, use C-M-d (down-list). In Lisp mode, where ( is the only opening delimiter, this is nearly the same as searching for a (. An argument specifies the number of levels to go down.

Emacs has a number of parenthesis matching features, which make it easy to see how and whether parentheses (or other paired delimiters) match up. Whenever you type a self-inserting character that is a closing delimiter, Emacs briefly indicates the location of the matching opening delimiter, provided that is on the screen. If it is not on the screen, Emacs displays some of the text near it in the echo area. Either way, you can tell which grouping you are closing off. If the opening delimiter and closing delimiter are mismatched—such as in [x)—a warning message is displayed in the echo area. Three variables control the display of matching parentheses:

• blink-matching-paren turns the feature on or off: nil disables it, but the default is t to enable it. Set it to jump to make indication work by momentarily moving the cursor to the matching opening delimiter. Set it to jump-offscreen to make the cursor jump, even if the opening delimiter is off screen.
• blink-matching-delay says how many seconds to keep indicating the matching opening delimiter. This may be an integer or floating-point number; the default is 1.
• blink-matching-paren-distance specifies how many characters back to search to find the matching opening delimiter. If the match is not found in that distance, Emacs stops scanning and nothing is displayed. The default is 102400.

Show Paren mode is a minor mode that provides a more powerful kind of automatic matching. Whenever point is before an opening delimiter or after a closing delimiter, the delimiter, its matching delimiter, and optionally the text between them are highlighted. To toggle Show Paren mode globally, type M-x show-paren-mode. To toggle it only in the current buffer, type M-x show-paren-local-mode. By default, this mode is switched on in all buffers that are meant for editing, but is not enabled in buffers that show data. This is controlled by the show-paren-predicate user option. To customize the mode, type M-x customize-group =RET paren-showing=. The customizable options which control the operation of this mode include:

• show-paren-highlight-openparen controls whether to highlight an open paren when point is just before it, and hence its position is marked by the cursor anyway. The default is non-nil (yes).
• show-paren-style controls whether just the two parens, or also the text between them get highlighted. The valid options here are parenthesis (show the matching paren), expression (highlight the entire expression enclosed by the parens), and mixed (highlight the matching paren if it is visible in the window, the expression otherwise).
• show-paren-when-point-inside-paren, when non-nil, causes highlighting also when point is inside of the parentheses. The default is nil.
• show-paren-when-point-in-periphery, when non-nil, causes highlighting also when point is in whitespace at the beginning of a line and there is a paren at the first or last non-whitespace position on the line, or when point is at the end of a line and there is a paren at the last non-whitespace position on the line.
• show-paren-context-when-offscreen, when non-nil, shows some context in the echo area when point is in a closing delimiter and the opening delimiter is offscreen. The context is usually the line that contains the opening delimiter, except if the opening delimiter is on its own line, in which case the context includes the previous nonblank line.
• If the value of show-paren-not-in-comments-or-strings is all, delimiters inside comments and strings will not be highlighted. Otherwise, if the value is set to on-mismatch, the mismatched delimiters inside comments will not be highlighted. The default is nil, so delimiters inside comments and strings are always highlighted.

Electric Pair mode is a minor mode that provides a way to easily insert pairs of matching delimiters: parentheses, braces, brackets, quotes, etc. (what counts as matching delimiters depends on the major mode). To toggle Electric Pair mode globally, type M-x electric-pair-mode. To toggle it only in the current buffer, type M-x electric-pair-local-mode. When this mode is enabled, typing an opening delimiter inserts both that character and, immediately following it, the matching closing delimiter, leaving point between the two. This makes it unnecessary to type a matching closing delimiter in most cases. If you type one nonetheless, Emacs simply inserts that character, unless point is immediately before a closing delimiter of the same type; in that case, point moves to immediately after the closing delimiter and no additional closing delimiter is inserted. Thus, typing the sequence <opening delimiter>, <matching closing delimiter> is a perhaps more convenient alternative to the sequence <opening delimiter>, C-f. With an active region (Mark), Electric Pair mode operates differently: inserting either an opening or a closing delimiter encloses the characters in the region within the resulting pair of matching delimiters, leaving point after the delimiter you typed (this facilitates continuing to type either before the text following the opening delimiter or after the closing delimiter). If you provide a prefix argument when inserting an opening delimiter—and if the region is active, also when inserting a closing delimiter—this results in the insertion of as many nested pairs of matching delimiters as the numeric value of that prefix argument. There are several user options for modifying the behavior of Electric Pair mode:

• electric-pair-preserve-balance, when non-nil (the default), makes typing a delimiter preserve the balance between opening and closing delimiters. Thus, if you type an opening delimiter and there is an unpaired matching closing delimiter later in the buffer, then only the opening delimiter gets inserted (and not a matching closing delimiter immediately following it); likewise, if there is an unpaired opening delimiter, then typing a matching closing delimiter later in the buffer inserts this character even when the following character is another matching closing delimiter. When set to nil, typing an opening delimiter inserts only this character, but only when point is either immediately before or immediately after a matching opening delimiter, or immediately before a letter or digit; in all other positions inserting an opening delimiter automatically inserts a matching closing delimiter immediately following it, even if there is an unpaired matching closing delimiter later in the buffer. And typing a closing delimiter immediately before another closing delimiter of the same type does not insert that character but moves point as described above, even when there is an unpaired matching opening delimiter earlier in the buffer. If there is an active region, this variable has no effect.
• electric-pair-delete-adjacent-pairs, when non-nil (the default), makes deleting an opening delimiter by typing the DEL key (which is normally the BACKSPACE key; DEL Does Not Delete) automatically also delete an immediately following matching closing delimiter (but not if there are any characters—including just whitespace—between the paired delimiters). When set to nil, typing BACKSPACE deletes only the opening delimiter. (Typing BACKSPACE to delete a closing delimiter always deletes only this character.)
• When electric-pair-open-newline-between-pairs is non-nil (the default) and point is between an opening delimiter and an immediately following matching closing delimiter, then typing a newline automatically inserts an extra newline after point (possibly indenting the empty line point is on, depending on the major mode). When set to nil, typing a newline inserts only one newline before point, as usual.
• When electric-pair-skip-whitespace has its default non-nil value and point is separated from a closing delimiter only by whitespace, then typing a closing delimiter of the same type does not insert that character but instead moves point to immediately after the already present closing delimiter. You can also set this option to additionally delete any whitespace that point moves over. When set to nil, typing a closing delimiter simply inserts that character (even when this makes the following closing delimiter of the same type unbalanced).

The following commands operate on comments:

M-;

Insert or realign comment on current line; if the region is active, comment or uncomment the region instead (comment-dwim).

C-x C-;

Comment or uncomment the current line (comment-line). If the region is active, comment or uncomment the lines in the region instead.

C-u M-;

Kill comment on current line (comment-kill).

C-x ;

Set comment column (comment-set-column).

C-M-j, M-j

Like RET followed by inserting and aligning a comment (default-indent-new-line). Multi-Line Comments.

M-x comment-region, C-c C-c (in C-like modes)

Add comment delimiters to all the lines in the region.

The command to create or align a comment is M-; (comment-dwim). The word "dwim" is an acronym for "Do What I Mean"; it indicates that this command can be used for many different jobs relating to comments, depending on the situation where you use it. When a region is active (Mark), M-; either adds comment delimiters to the region, or removes them. If every line in the region is already a comment, it uncomments each of those lines by removing their comment delimiters. Otherwise, it adds comment delimiters to enclose the text in the region. If you supply a prefix argument to M-; when a region is active, that specifies the number of comment delimiters to add or delete. A positive argument n adds n delimiters, while a negative argument -n removes n delimiters. If the region is not active, and there is no existing comment on the current line, M-; adds a new comment to the current line. If the line is blank (i.e., empty or containing only whitespace characters), the comment is indented to the same position where TAB would indent to (Basic Indent). If the line is non-blank, the comment is placed after the last non-whitespace character on the line. Emacs tries to fit the comment between the columns specified by the variables comment-column and comment-fill-column (Options for Comments), if possible. Otherwise, it will choose some other suitable position, usually separated from the non-comment text by at least one space. In each case, Emacs places point after the comment's starting delimiter, so that you can start typing the comment text right away. You can also use M-; to align an existing comment. If a line already contains the comment-start string, M-; realigns it to the conventional alignment and moves point after the comment's starting delimiter. As an exception, comments starting in column 0 are not moved. Even when an existing comment is properly aligned, M-; is still useful for moving directly to the start of the comment text. C-x C-; (comment-line) comments or uncomments complete lines. When a region is active (Mark), C-x C-; either comments or uncomments the lines in the region. If the region is not active, this command comments or uncomments the line point is on. With a positive prefix argument n, it operates on n lines starting with the current one; with a negative argument -n, it affects n preceding lines. After invoking this command with a negative argument, successive invocations with a positive argument will operate on preceding lines as if the argument were negated. C-u M-; (comment-dwim with a prefix argument) when the region is not active kills any comment on the current line, along with the whitespace before it. Since the comment is saved to the kill ring, you can reinsert it on another line by moving to the end of that line, doing C-y, and then M-; to realign the comment. You can achieve the same effect as C-u M-; by typing M-x comment-kill (comment-dwim actually calls comment-kill as a subroutine when it is given a prefix argument). Invoking comment-dwim with a prefix numeric argument, as in C-u /n/ M-;, when there's no active region, tells comment-kill to kill comments on n lines. The command M-x comment-region is equivalent to calling M-; on an active region, except that it always acts on the region, even if the mark is inactive. In C mode and related modes, this command is bound to C-c C-c. The command M-x uncomment-region uncomments each line in the region; a numeric prefix argument specifies the number of comment delimiters to remove (negative arguments specify the number of comment delimiters to add). For C-like modes, you can configure the exact effect of M-; by setting the variables c-indent-comment-alist and c-indent-comments-syntactically-p. For example, on a line ending in a closing brace, M-; puts the comment one space after the brace rather than at comment-column. For full details see Comment Commands.

If you are typing a comment and wish to continue it to another line, type M-j or C-M-j (default-indent-new-line). This breaks the current line, and inserts the necessary comment delimiters and indentation to continue the comment. For languages with closing comment delimiters (e.g., */ in C), the exact behavior of M-j depends on the value of the variable comment-multi-line. If the value is nil, the command closes the comment on the old line and starts a new comment on the new line. Otherwise, it opens a new line within the current comment delimiters. When Auto Fill mode is on, going past the fill column while typing a comment also continues the comment, in the same way as an explicit invocation of M-j. To turn existing lines into comment lines, use M-; with the region active, or use M-x comment-region (Comment Commands). as described in the preceding section. You can configure C Mode such that when you type a / at the start of a line in a multi-line block comment, this closes the comment. Enable the comment-close-slash clean-up for this. Clean-ups.

As mentioned in Comment Commands, when the M-j command adds a comment to a line, it tries to place the comment between the columns specified by the buffer-local variables comment-column and comment-fill-column (or if that is nil, then the value of fill-column, Fill Commands). You can set either the local value or the default value of these buffer-local variables in the usual way (Locals). Alternatively, you can type C-x ; (comment-set-column) to set the value of comment-column in the current buffer to the column where point is currently located. C-u C-x ; sets the comment column to match the last comment before point in the buffer, and then does a M-; to align the current line's comment under the previous one. The comment commands recognize comments based on the regular expression that is the value of the variable comment-start-skip. Make sure this regexp does 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 could be "/\\*+[ \t]*\\|//+[ \t]*", which matches extra stars and spaces after the /* itself, and accepts C++ style (//) comments also. (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. Regexp Backslash.) When a comment command makes a new comment, it inserts the value of comment-start as an opening comment delimiter. It also inserts the value of comment-end after point, as a closing comment delimiter. For example, in Lisp mode, comment-start is ";" and comment-end is "" (the empty string). In C mode, comment-start is "/* " and comment-end is " */". The variable comment-padding specifies a string that the commenting commands should insert between the comment delimiter(s) and the comment text. The default, " ", specifies a single space. Alternatively, the value can be a number, which specifies that number of spaces, or nil, which means no spaces at all. The variable comment-multi-line controls how M-j and Auto Fill mode continue comments over multiple lines. Multi-Line Comments. The variable comment-indent-function should contain a function that will be called to compute the alignment for a newly inserted comment or for aligning an existing comment. It is set differently by various major modes. 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. It should return the column in which the comment ought to start. For example, the default function bases its decision on how many comment characters begin an existing comment. Emacs also tries to align comments on adjacent lines. To override this, the function may return a cons of two (possibly equal) integers to indicate an acceptable range of indentation.

For major modes that apply to languages which have documentation in Info, you can use C-h S (info-lookup-symbol) to view the Info documentation for a symbol used in the program. You specify the symbol with the minibuffer; the default is the symbol appearing in the buffer at point. For example, in C mode this looks for the symbol in the C Library Manual. The command only works if the appropriate manual's Info files are installed. Emacs determines where to look for documentation for the symbol—which Info files to look in, and which indices to search—based on the major mode. You can also use M-x info-lookup-file to look for documentation for a file name. If you use C-h S in a major mode that does not support it, it asks you to specify the symbol help mode. You should enter a command such as c-mode that would select a major mode which C-h S does support.

On Unix, the main form of on-line documentation was the manual page or man page. In the GNU operating system, we aim to replace man pages with better-organized manuals that you can browse with Info (Misc Help). This process is not finished, so it is still useful to read manual pages. You can read the man page for an operating system command, library function, or system call, with the M-x man command. This prompts for a topic, with completion (Completion), and runs the man program to format the corresponding man page. If the system permits, it runs man asynchronously, so that you can keep on editing while the page is being formatted. The result goes in a buffer named *Man topic*. These buffers use a special major mode, Man mode, that facilitates scrolling and jumping to other manual pages. For details, type C-h m while in a Man mode buffer. Each man page belongs to one of ten or more sections, each named by a digit or by a digit and a letter. Sometimes there are man pages with the same name in different sections. To read a man page from a specific section, type /topic/(/section/) or /section/ /topic/ when M-x man prompts for the topic. For example, the man page for the C library function chmod is in section 2, but there is a shell command of the same name, whose man page is in section 1; to view the former, type M-x man RET chmod(2) RET. If you do not specify a section, M-x man normally displays only the first man page found. On some systems, the man program accepts a -a command-line option, which tells it to display all the man pages for the specified topic. To make use of this, change the value of the variable Man-switches to "-a". Then, in the Man mode buffer, you can type M-n and M-p to switch between man pages in different sections. The mode line shows how many manual pages are available. By default, M-x man calls the man program asynchronously. You can force the invocation to be synchronous by customizing Man-prefer-synchronous-call to a non-nil value. If the user option Man-support-remote-systems is non-nil, and default-directory indicates a remote system (Remote Files), the man page is taken from the remote system. Calling the man command with a prefix like C-u M-x man reverts the value of Man-support-remote-systems for that call. An alternative way of reading manual pages is the M-x woman command. Unlike M-x man, it does not run any external programs to format and display the man pages; the formatting is done by Emacs, so it works on systems such as MS-Windows where the man program may be unavailable. It prompts for a man page, and displays it in a buffer named *WoMan section topic. M-x woman computes the completion list for manpages the first time you invoke the command. With a numeric argument, it recomputes this list; this is useful if you add or delete manual pages. If you type a name of a manual page and M-x woman finds that several manual pages by the same name exist in different sections, it pops up a window with possible candidates asking you to choose one of them. Note that M-x woman doesn't yet support the latest features of modern man pages, so we recommend using M-x man if that is available on your system. For more information about setting up and using M-x woman, see Browse UN*X Manual Pages WithOut Man. the WoMan Info manual, which is distributed with Emacs.

When editing Emacs Lisp code, you can use the commands C-h f (describe-function) and C-h v (describe-variable) to view the built-in documentation for the Lisp functions and variables that you want to use. Name Help. ElDoc(The name "ElDoc" is a historical accident: this mode started by supporting Emacs Lisp buffers.) is a buffer-local minor mode that helps with looking up documentation of symbols (functions, methods, classes, variables, etc.) in your program. When this mode is enabled, the echo area displays useful information whenever there is a documented symbol at point. For example, in buffers under the Emacs Lisp mode, it shows the argument list of a function at point, and for a Lisp variable it shows the first line of the variable's documentation string. To toggle ElDoc mode, type M-x eldoc-mode. There's also a Global ElDoc mode, which is turned on by default, and turns on the ElDoc mode in buffers whose major mode sets the variables described below. Use M-x global-eldoc-mode to turn it off globally. Various major modes configure the Global ElDoc mode to use their documentation functions. Examples include Emacs Lisp mode, Python mode, and Cfengine mode. In addition, Emacs features that provide support for several major modes configure ElDoc to use their facilities for retrieving the documentation. Examples include Eglot (Eglot Features), which provides documentation based on information from language servers; Semantic's Idle Summary mode (Idle Summary Mode); and Flymake, which uses ElDoc to show diagnostics at point (Finding diagnostics). The ElDoc mode works by scheduling the display of the available documentation for the symbol at point after Emacs has been idle for some short time. This avoids annoying flickering of documentation messages in the echo area or the mode line when you type quickly and without delay. You can also trigger the display of documentation for a symbol at point by using the command M-x eldoc-print-current-symbol-info. The following variables can be used to configure ElDoc mode: @vtable @code - eldoc-idle-delay The value of this user option controls the amount of idle time before the at-point documentation is displayed. It should be set to the number of seconds to wait; the value of zero means to display without any delay. The default is 0.5 sec. - eldoc-print-after-edit If this user option is non-nil, ElDoc will show documentation only after some editing command, like inserting or deleting some text. This comes in handy if you want Emacs to display documentation only about symbols that you type, but not about symbols that are already in the buffer (so just reading the source code will not show documentation). The default value is nil. If you change the value, you need to toggle eldoc-mode off and on again. - eldoc-echo-area-use-multiline-p This user option controls whether and how to truncate documentation text if it is longer than the echo-area can display as a single screen line. If the value is a positive number, it specifies the number of screen lines that ElDoc is allowed to display in the echo area without truncating the documentation. A positive integer specifies the absolute maximum number of screen lines to use; a floating-point number specifies the number of screen lines as a fraction of the frame's height. The value of t means never truncate the documentation (the echo-area will be resized up to the height allowed by max-mini-window-height, Minibuffer Edit), whereas the value of nil means truncate if the documentation is longer than a single screen line. Finally, the special value truncate-sym-name-if-fit (the default) means to truncate the part of the documentation that represents a symbol's name if doing that will allow the documentation to fit on a single screen line. - eldoc-echo-area-display-truncation-message If non-nil (the default), and documentation shown in the echo area is truncated because it's too long, follow the documentation by instructions about how to view the complete documentation text. If nil, just indicate with ... that the documentation was truncated. - eldoc-echo-area-prefer-doc-buffer If the value of this user option is t, ElDoc will not show the documentation in the echo area if the ElDoc buffer with the documentation is already displayed in some window. (You can use the command M-x eldoc-doc-buffer any time to show the ElDoc buffer.) If the value of this option is the symbol maybe, the documentation will not be displayed in the echo area if the ElDoc buffer is shown in some window, and the documentation text has to be truncated if displayed in the echo area. Finally, the value of nil (the default) means always show the documentation in the echo area. - eldoc-documentation-strategy This customizable variable's value is the function which is used to retrieve and display documentation for the symbol at point. The documentation is produced by the functions in the hook eldoc-documentation-functions. The default value of eldoc-documentation-strategy specifies that ElDoc should display the first documentation text produced by functions in the eldoc-documentation-functions hook, but you can customize eldoc-documentation-strategy to work in other ways, such as displaying all of the documentation texts concatenated together. - eldoc-documentation-functions This abnormal hook's value is a list of functions that can produce documentation for the symbol at point as appropriate for the current buffer's major-mode. These functions act as a collection of backends for ElDoc. Major modes register their documentation lookup functions with ElDoc by adding their functions to the buffer-local value of this variable. @end vtable

This section describes commands for moving point, in C mode and related modes.

C-M-a, C-M-e

Move point to the beginning or end of the current function or top-level definition. In languages with enclosing scopes (such as C++'s classes) the current function is the immediate one, possibly inside a scope. Otherwise it is the one defined by the least enclosing braces. (By contrast, beginning-of-defun and end-of-defun search for braces in column zero.) Moving by Defuns.

C-c C-u

Move point back to the containing preprocessor conditional, leaving the mark behind. A prefix argument acts as a repeat count. With a negative argument, move point forward to the end of the containing preprocessor conditional. #elif is equivalent to #else followed by #if, so the function will stop at a #elif when going backward, but not when going forward.

C-c C-p

Move point back over a preprocessor conditional, leaving the mark behind. A prefix argument acts as a repeat count. With a negative argument, move forward.

C-c C-n

Move point forward across a preprocessor conditional, leaving the mark behind. A prefix argument acts as a repeat count. With a negative argument, move backward.

M-a

Move point to the beginning of the innermost C statement (c-beginning-of-statement). If point is already at the beginning of a statement, move to the beginning of the preceding statement. With prefix argument n, move back n - 1 statements. In comments or in strings which span more than one line, this command moves by sentences instead of statements.

M-e

Move point to the end of the innermost C statement or sentence; like M-a except that it moves in the other direction (c-end-of-statement).

In C mode and related modes, certain printing characters are electric—in addition to inserting themselves, they also reindent the current line, and optionally also insert newlines. The electric characters are @{}, :, #, ;, =, =<, >, /, *, (, and ). You might find electric indentation inconvenient if you are editing chaotically indented code. If you are new to CC Mode, you might find it disconcerting. You can toggle electric action with the command C-c C-l; when it is enabled, //c/l appears in the mode line after the mode name (where c, if present, is * or /, depending on whether the comment style is block or line). Minor Modes, for more about mode-line indicators in CC Mode.

C-c C-l

Toggle electric action (c-toggle-electric-state). With a positive prefix argument, this command enables electric action, with a negative one it disables it.

Electric characters insert newlines only when, in addition to the electric state, the auto-newline feature is enabled (indicated by //c/la in the mode line after the mode name). You can turn this feature on or off with the command C-c C-a:

C-c C-a

Toggle the auto-newline feature (c-toggle-auto-newline). With a prefix argument, this command turns the auto-newline feature on if the argument is positive, and off if it is negative.

Usually the CC Mode style configures the exact circumstances in which Emacs inserts auto-newlines. You can also configure this directly. Custom Auto-newlines.

If you want to delete an entire block of whitespace at point, you can use hungry deletion. This deletes all the contiguous whitespace either before point or after point in a single operation. Whitespace here includes tabs and newlines, but not comments or preprocessor commands.

C-c C-DEL, C-c DEL

Delete the entire block of whitespace preceding point (c-hungry-delete-backwards).

C-c C-d, C-c C-Delete, C-c Delete

Delete the entire block of whitespace after point (c-hungry-delete-forward).

As an alternative to the above commands, you can enable hungry delete mode. When this feature is enabled (indicated by h after a / in the mode line after the mode name), a single DEL deletes all preceding whitespace, not just one space, and a single C-d (but not plain Delete) deletes all following whitespace.

M-x c-toggle-hungry-state

Toggle the hungry-delete feature (c-toggle-hungry-state). With a prefix argument, this command turns the hungry-delete feature on if the argument is positive, and off if it is negative.

The variable c-hungry-delete-key controls whether the hungry-delete feature is enabled.

M-x c-context-line-break

This command inserts a line break and indents the new line in a manner appropriate to the context. In normal code, it does the work of RET (newline), in a C preprocessor line it additionally inserts a \ at the line break, and within comments it's like M-j (c-indent-new-comment-line). c-context-line-break isn't bound to a key by default, but it needs a binding to be useful. The following code will bind it to RET. We use c-initialization-hook here to make sure the keymap is loaded before we try to change it. (defun my-bind-clb () (keymap-set c-mode-base-map "RET" 'c-context-line-break)) (add-hook 'c-initialization-hook 'my-bind-clb)

C-M-h

Put mark at the end of a function definition, and put point at the beginning (c-mark-function).

M-q

Fill a paragraph, handling C and C++ comments (c-fill-paragraph). If any part of the current line is a comment or within a comment, this command fills the comment or the paragraph of it that point is in, preserving the comment indentation and comment delimiters.

C-c C-e

Run the C preprocessor on the text in the region, and show the result, which includes the expansion of all the macro calls (c-macro-expand). The buffer text before the region is also included in preprocessing, for the sake of macros defined there, but the output from this part isn't shown. When you are debugging C code that uses macros, sometimes it is hard to figure out precisely how the macros expand. With this command, you don't have to figure it out; you can see the expansions.

C-c C-\

Insert or align \ characters at the ends of the lines of the region (c-backslash-region). This is useful after writing or editing a C macro definition. If a line already ends in \, this command adjusts the amount of whitespace before it. Otherwise, it inserts a new \. However, the last line in the region is treated specially; no \ is inserted on that line, and any \ there is deleted.

M-x cpp-highlight-buffer

Highlight parts of the text according to its preprocessor conditionals. This command displays another buffer named *CPP Edit*, which serves as a graphic menu for selecting how to display particular kinds of conditionals and their contents. After changing various settings, click on [A]pply these settings (or go to that buffer and type a) to rehighlight the C mode buffer accordingly.

C-c C-s

Display the syntactic information about the current source line (c-show-syntactic-information). This information directs how the line is indented.

M-x cwarn-mode, M-x global-cwarn-mode

CWarn minor mode highlights certain suspicious C and C++ constructions:

?

:: Assignments inside expressions.

?

:: Semicolon following immediately after if, for, and while (except after a do ... while statement);

?

:: C++ functions with reference parameters. You can enable the mode for one buffer with the command M-x cwarn-mode, or for all suitable buffers with the command M-x global-cwarn-mode or by customizing the variable global-cwarn-mode. You must also enable Font Lock mode to make it work.

M-x hide-ifdef-mode

Hide-ifdef minor mode hides selected code within #if and #ifdef preprocessor blocks. If you change the variable hide-ifdef-shadow to t, Hide-ifdef minor mode shadows preprocessor blocks by displaying them with a less prominent face, instead of hiding them entirely. See the documentation string of hide-ifdef-mode for more information.

M-x ff-find-related-file

Find a file related in a special way to the file visited by the current buffer. Typically this will be the header file corresponding to a C/C++ source file, or vice versa. The variable ff-related-file-alist specifies how to compute related file names.

In addition to the normal commands for moving by and operating on defuns (Fortran subprograms—functions and subroutines, as well as modules for F90 mode, using the commands fortran-end-of-subprogram and fortran-beginning-of-subprogram), Fortran mode provides special commands to move by statements and other program units.

C-c C-n

Move to the beginning of the next statement (fortran-next-statement=/=f90-next-statement).

C-c C-p

Move to the beginning of the previous statement (fortran-previous-statement=/=f90-previous-statement). If there is no previous statement (i.e., if called from the first statement in the buffer), move to the start of the buffer.

C-c C-e

Move point forward to the start of the next code block, or the end of the current one, whichever comes first (f90-next-block). A code block is a subroutine, if–endif statement, and so forth. This command exists for F90 mode only, not Fortran mode. With a numeric argument, it moves forward that many blocks.

C-c C-a

Move point backward to the previous block (f90-previous-block). This is like f90-next-block, but moves backwards.

C-M-n

Move to the end of the current code block (fortran-end-of-block=/=f90-end-of-block). With a numeric argument, move forward that number of blocks. The mark is set before moving point. The F90 mode version of this command checks for consistency of block types and labels (if present), but it does not check the outermost block since that may be incomplete.

C-M-p

Move to the start of the current code block (fortran-beginning-of-block=/=f90-beginning-of-block). This is like fortran-end-of-block, but moves backwards.

The commands fortran-beginning-of-subprogram and fortran-end-of-subprogram move to the start or end of the current subprogram, respectively. The commands fortran-mark-do and fortran-mark-if mark the end of the current do or if block, and move point to the start.

Special commands and features are needed for indenting fixed (or tab) form Fortran code in order to make sure various syntactic entities (line numbers, comment line indicators and continuation line flags) appear in the required columns.

The usual Emacs comment commands assume that a comment can follow a line of code. In Fortran 77, 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 the Fortran 90 comment syntax where comments start with ! and can follow other text. Because only some Fortran 77 compilers accept this syntax, Fortran mode will not insert such comments unless you have said in advance to do so. To do this, set the variable fortran-comment-line-start to "!". If you use an unusual value, you may need to change fortran-comment-line-start-skip.

M-;

Align comment or insert new comment (comment-dwim).

C-x ;

Applies to nonstandard ! comments only (comment-set-column).

C-c ;

Turn all lines of the region into comments, or (with argument) turn them back into real code (fortran-comment-region).

M-; in Fortran mode runs the standard comment-dwim. This recognizes any kind of existing comment and aligns its text appropriately; if there is no existing comment, a comment is inserted and aligned. Inserting and aligning comments are not the same in Fortran mode as in other modes. When a new comment must be inserted, if the current line is blank, a full-line comment is inserted. On a non-blank line, a nonstandard ! comment is inserted if you have said you want to use them. Otherwise, a full-line comment is inserted on a new line before the current line. Nonstandard ! comments are aligned like comments in other languages, but full-line comments are different. 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

Align the text at a fixed column, which is the sum of fortran-comment-line-extra-indent and the minimum statement indentation. This is the default. The minimum indentation is fortran-minimum-statement-indent-tab for tab format continuation line style and fortran-minimum-statement-indent-fixed for fixed form style.

relative

Align the text as if it were a line of code, but with an additional fortran-comment-line-extra-indent columns of indentation.

nil

Don't move text in full-line comments automatically.

In addition, you can specify the character to be used to indent within full-line comments by setting the variable fortran-comment-indent-char to the single-character string you want to use. Compiler directive lines, or preprocessor lines, have much the same appearance as comment lines. It is important, though, that such lines never be indented at all, no matter what the value of fortran-comment-indent-style. The variable fortran-directive-re is a regular expression that specifies which lines are directives. Matching lines are never indented, and receive distinctive font-locking. The normal Emacs comment command C-x ; (comment-set-column) has not been redefined. If you use ! comments, this command can be used with them. Otherwise, it is useless in Fortran mode. 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 argument, it turns the region back into live code by deleting c$$$ from the front of each line in it. The string used for these comments can be controlled by setting the variable fortran-comment-region. Note that here we have an example of a command and a variable with the same name; these two uses of the name never conflict because in Lisp and in Emacs it is always clear from the context which one is meant.

Fortran mode has specialized support for Auto Fill mode, which is a minor mode that automatically splits statements as you insert them when they become too wide. Splitting a statement involves making continuation lines using fortran-continuation-string (ForIndent Cont). This splitting happens when you type SPC, RET, or TAB, and also in the Fortran indentation commands. You activate Auto Fill in Fortran mode in the normal way. Auto Fill. Auto Fill breaks lines at spaces or delimiters when the lines get longer than the desired width (the value of fill-column). The delimiters (besides whitespace) that Auto Fill can break at are +, -, /, *, =, <, >, and =. The line break comes after the delimiter if the variable =fortran-break-before-delimiters is nil. Otherwise (and by default), the break comes before the delimiter. To enable Auto Fill in all Fortran buffers, add auto-fill-mode to fortran-mode-hook. Hooks.

In standard Fortran 77, anything beyond column 72 is ignored. Most compilers provide an option to change this (for example, -ffixed-line-length-N in gfortran). Customize the variable fortran-line-length to change the line length in Fortran mode. Anything beyond this point is font-locked as a comment. (Unless it is inside a string: strings that extend beyond fortran-line-length will confuse font-lock.)

C-c C-r

Display a column ruler momentarily above the current line (fortran-column-ruler).

C-c C-w

Split the current window horizontally temporarily so that it is fortran-line-length columns wide (fortran-window-create-momentarily). This may help you avoid making lines longer than the limit imposed by your Fortran compiler.

C-u C-c C-w

Split the current window horizontally so that it is fortran-line-length columns wide (fortran-window-create). You can then continue editing.

M-x fortran-strip-sequence-nos

Delete all text in column fortran-line-length and beyond.

The command C-c C-r (fortran-column-ruler) shows a column ruler momentarily above the current line. The comment ruler is 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 GNU Emacs (but customizing column-number-indicator-zero-based can change column display to match that of Fortran; Optional Mode Line.) As a result, the numbers may be one less than those you are familiar with; but the positions they indicate in the line are standard for Fortran. The text used to display the column ruler depends on the value of the variable indent-tabs-mode. If indent-tabs-mode is nil, then the value of the variable fortran-column-ruler-fixed is used as the column ruler. Otherwise, the value of the variable fortran-column-ruler-tab is displayed. By changing these variables, you can change the column ruler display. C-c C-w (fortran-window-create-momentarily) temporarily splits the current window horizontally, making a window fortran-line-length columns wide, so you can see any lines that are too long. Type a space to restore the normal width. You can also split the window horizontally and continue editing with the split in place. To do this, use C-u C-c C-w (M-x fortran-window-create). By editing in this window you can immediately see when you make a line too wide to be correct Fortran. The command M-x fortran-strip-sequence-nos deletes all text in column fortran-line-length and beyond, on all lines in the current buffer. This is the easiest way to get rid of old sequence numbers.

Fortran mode provides many built-in abbrevs for common keywords and declarations. These are the same sort of abbrev that you can define yourself. To use them, you must turn on Abbrev mode. Abbrevs. The built-in abbrevs are unusual in one way: they all start with a semicolon. 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 expands automatically to continue, provided Abbrev mode is enabled. Type ;? or ;C-h to display a list of all the built-in Fortran abbrevs and what they stand for.