File:  [Local Repository] / gnujdoc / emacs-20.6 / programs-ja.texi
Revision 1.1: download - view: text, annotated - select for diffs
Wed Apr 26 06:42:34 2000 UTC (20 years, 3 months ago) by hayashi
Branches: MAIN
CVS tags: HEAD
New files

@c =============================================================
@c = 元 翻 訳: 赤池英夫@電気通信大学
@c = 加筆修正: 大木敦雄@大塚.筑波大学 = 1998/11/25
@c = 20.4改訂: 大木敦雄@大塚.筑波大学 = 1999/09/12
@c =============================================================
@c This is part of the Emacs manual.
@c Copyright (C) 1985, 86, 87, 93, 94, 95, 1997 Free Software Foundation, Inc.
@c See file emacs.texi for copying conditions.
@node Programs, Building, Text, Top
@c @chapter Editing Programs
@chapter プログラムの編集
@c @cindex Lisp editing
@c @cindex C editing
@c @cindex program editing
@cindex Lispの編集
@cindex Cの編集
@cindex プログラムの編集

@c   Emacs has many commands designed to understand the syntax of programming
@c languages such as Lisp and C.  These commands can
Emacsには、LispやCといったプログラム言語の構文を
理解するように設計されたコマンドが数多くあります。
以下のことを行えます。

@itemize @bullet
@item
@c Move over or kill balanced expressions or @dfn{sexps} (@pxref{Lists}).
釣り合った式や@dfn{S式}(@pxref{Lists})を横断したりそれらをキルする。
@item
@c Move over or mark top-level expressions---@dfn{defuns}, in Lisp;
@c functions, in C (@pxref{Defuns}).
トップレベルの式、つまり、Lispの@dfn{defun}やCの関数(@pxref{Defuns})を
横断したりそれらにマークを設定する。
@item
@c Show how parentheses balance (@pxref{Matching}).
括弧の対応具合を表示する(@pxref{Matching})。
@item
@c Insert, kill or align comments (@pxref{Comments}).
コメントの挿入/キル/整列(@pxref{Comments})。
@item
@c Follow the usual indentation conventions of the language
@c (@pxref{Program Indent}).
使用言語の慣用的な字下げを踏襲する(@pxref{Program Indent})。
@end itemize

@c   The commands for words, sentences and paragraphs are very useful in
@c editing code even though their canonical application is for editing
@c human language text.  Most symbols contain words (@pxref{Words});
@c sentences can be found in strings and comments (@pxref{Sentences}).
@c Paragraphs per se don't exist in code, but the paragraph commands are
@c useful anyway, because programming language major modes define
@c paragraphs to begin and end at blank lines (@pxref{Paragraphs}).
@c Judicious use of blank lines to make the program clearer will also
@c provide useful chunks of text for the paragraph commands to work
@c on.
単語/文/段落を扱うコマンドは、
自然言語のテキストを編集するのが本来の目的ですが、
コードを編集する場合にもおおいに役立ちます。
なぜなら、たいていのシンボルは単語ですし(@pxref{Words})、
文は文字列やコメントの中にも含まれるからです(@pxref{Sentences})。
段落は本質的にはコードの中には存在しませんが、
プログラム言語向けのメジャーモードでは、
段落は空行で始まり空行で終わると定義するので、
段落コマンドも役立ちます(@pxref{Paragraphs})。
空行をうまく使ってプログラムが整然と見えるようにすると、
段落コマンドもうまく働きます。

@c   The selective display feature is useful for looking at the overall
@c structure of a function (@pxref{Selective Display}).  This feature causes
@c only the lines that are indented less than a specified amount to appear
@c on the screen.
選択的表示機能は、関数の全体構成を眺めるのに便利です
(@pxref{Selective Display})。
この機能は、指定幅以内の字下げ幅の行だけを表示します。

@menu
* Program Modes::       Major modes for editing programs.
* Lists::	        Expressions with balanced parentheses.
* List Commands::       The commands for working with list and sexps.
* Defuns::	        Each program is made up of separate functions.
			  There are editing commands to operate on them.
* Program Indent::      Adjusting indentation to show the nesting.
* Matching::	        Insertion of a close-delimiter flashes matching open.
* Comments::	        Inserting, killing, and aligning comments.
* Balanced Editing::    Inserting two matching parentheses at once, etc.
* Symbol Completion::   Completion on symbol names of your program or language.
* Which Function::      Which Function mode shows which function you are in.
* Documentation::       Getting documentation of functions you plan to call.
* Change Log::	        Maintaining a change history for your program.
* Tags::	        Go direct to any function in your program in one
			  command.  Tags remembers which file it is in.
* Emerge::	        A convenient way of merging two versions of a program.
* C Modes::             Special commands of C, C++, Objective-C, 
                          Java, and Pike modes.
* Fortran::	        Fortran mode and its special features.
* Asm Mode::	        Asm mode and its special features.
@end menu

@node Program Modes, Lists, , Programs
@c @section Major Modes for Programming Languages
@section プログラム言語向けメジャーモード

@c @cindex modes for programming languages
@cindex プログラム言語向けモード
@c @cindex Perl mode
@c @cindex Icon mode
@c @cindex Awk mode
@c @cindex Makefile mode
@c @cindex Tcl mode
@c @cindex CPerl mode
@cindex Perlモード
@cindex Iconモード
@cindex Awkモード
@cindex Makefileモード
@cindex Tclモード
@cindex CPerlモード
@c   Emacs also has major modes for the programming languages Lisp, Scheme
@c (a variant of Lisp), Awk, C, C++, Fortran, Icon, Java, Objective-C,
@c Pascal, Perl, Pike, CORBA IDL, and Tcl.  There is also a major mode for
@c makefiles, called Makefile mode.  An second alternative mode for Perl is
@c called CPerl mode.
Emacsには、Lisp、Scheme(Lispの方言の1つ)、Awk、C、C++、Fortran、
Icon、Java、Objective-C、Pascal、Perl、Pike、CORBA IDL、
Tclといった各種プログラム言語向けのメジャーモードがあります。
makefile用のメジャーモード、makefileモードもあります。
Perl向けの別のモードとして、cperlモードもあります。

@c   Ideally, a major mode should be implemented for each programming
@c language that you might want to edit with Emacs; but often the mode for
@c one language can serve for other syntactically similar languages.  The
@c language modes that exist are those that someone decided to take the
@c trouble to write.
理想的には、Emacsで編集する可能性のあるすべてのプログラム言語に対して、
それぞれのメジャーモードを実装すべきです。
しかし、ある言語向けのモードが、構文的に類似した他の言語にも
使えることがよくあります。
既存の言語モード群は、誰かがわざわざ書こうと決心したものです。

@c   There are several forms of Lisp mode, which differ in the way they
@c interface to Lisp execution.  @xref{Executing Lisp}.
Lispモードにはいくつか変種がありますが、
Lispを実行する際のインターフェイス方法が異なります。
@xref{Executing Lisp}。

@c   Each of the programming language major modes defines the @key{TAB} key
@c to run an indentation function that knows the indentation conventions of
@c that language and updates the current line's indentation accordingly.
@c For example, in C mode @key{TAB} is bound to @code{c-indent-line}.
@c @kbd{C-j} is normally defined to do @key{RET} followed by @key{TAB};
@c thus, it too indents in a mode-specific fashion.
各プログラム言語向けメジャーモードでは、
その言語の慣用的な字下げ方法を理解し
現在行をそのように字下げする関数を実行するように
@key{TAB}キーを定義します。
たとえば、Cモードでは、@key{TAB}は@code{c-indent-line}にバインドされています。
また、@kbd{C-j}は、@key{RET}に続けて@key{TAB}を実行するように
定義されています。
つまり、モードに固有の字下げも行います。

@c @kindex DEL @r{(programming modes)}
@kindex DEL @r{(プログラミングモード)}
@findex backward-delete-char-untabify
@c   In most programming languages, indentation is likely to vary from line to
@c line.  So the major modes for those languages rebind @key{DEL} to treat a
@c tab as if it were the equivalent number of spaces (using the command
@c @code{backward-delete-char-untabify}).  This makes it possible to rub out
@c indentation one column at a time without worrying whether it is made up of
@c spaces or tabs.  Use @kbd{C-b C-d} to delete a tab character before point,
@c in these modes.
多くのプログラム言語では、行ごとに字下げ量が異なります。
そのため、そのような言語向けのメジャーモードでは、
(コマンド@code{backward-delete-char-untabify}を使って)
タブ文字を等価な個数の空白と同じに扱うように@key{DEL}を再定義しています。
その結果、字下げが空白かタブのどちらで構成されているのか気にせずに、
1度に1桁ずつ消去することが可能となります。
そのようなモードでは、ポイントの直前にあるタブ文字を削除するには
@kbd{C-b C-d}を使います。

@c   Programming language modes define paragraphs to be separated only by
@c blank lines, so that the paragraph commands remain useful.  Auto Fill mode,
@c if enabled in a programming language major mode, indents the new lines
@c which it creates.
プログラム言語向けモードでは、段落は空行で分割されると定義するので、
段落コマンドも便利に使えます。
プログラム言語向けメジャーモードで
自動詰め込み(auto-fill)モードがオンのときには、
新たに行を作ると自動的に字下げも行われます。

@c @cindex mode hook
@cindex モードフック
@vindex c-mode-hook
@vindex lisp-mode-hook
@vindex emacs-lisp-mode-hook
@vindex lisp-interaction-mode-hook
@vindex scheme-mode-hook
@vindex muddle-mode-hook
@c   Turning on a major mode runs a normal hook called the @dfn{mode hook},
@c which is the value of a Lisp variable.  Each major mode has a mode hook,
@c and the hook's name is always made from the mode command's name by
@c adding @samp{-hook}.  For example, turning on C mode runs the hook
@c @code{c-mode-hook}, while turning on Lisp mode runs the hook
@c @code{lisp-mode-hook}.  @xref{Hooks}.
メジャーモードに入ると、@dfn{モードフック}(mode hook)と
呼ばれるノーマルフックが実行されます。
モードフックは、Lisp変数の値です。
各メジャーモードにはモードフックがあり、
フック名はつねにモードに入るためのコマンド名に@samp{-hook}を付加したものです。
たとえば、Cモードに入るとフック@code{c-mode-hook}が実行され、
Lispモードではフック@code{lisp-mode-hook}が実行されます。
@xref{Hooks}。

@node Lists, List Commands, Program Modes, Programs
@c @section Lists and Sexps
@section リストとS式

@c @cindex Control-Meta
@cindex コントロール・メタ
@c   By convention, Emacs keys for dealing with balanced expressions are
@c usually Control-Meta characters.  They tend to be analogous in
@c function to their Control and Meta equivalents.  These commands are
@c usually thought of as pertaining to expressions in programming
@c languages, but can be useful with any language in which some sort of
@c parentheses exist (including human languages).
慣習として、釣り合った式を扱うEmacsのキーは、普通、コントロール・メタ文字です。
これらは、コントロールやメタだけの対応したキーの機能に似せてあります。
これらは、プログラム言語の式だけに関係したコマンドだと考えられがちですが、
ある種の括弧が存在する(自然言語も含めた)任意の言語に対しても有益なものです。

@c @cindex list
@c @cindex sexp
@c @cindex expression
@cindex リスト
@cindex S式
@cindex 式
@c   These commands fall into two classes.  Some deal only with @dfn{lists}
@c (parenthetical groupings).  They see nothing except parentheses, brackets,
@c braces (whichever ones must balance in the language you are working with),
@c and escape characters that might be used to quote those.
これらのコマンドは、2つのグループに分けられます。
一方は(括弧でまとめた)@dfn{リスト}(list)@footnote{【訳注】
ここでは、Lispの「リスト」ではなく、
単に括弧で括った一塊のこと。}だけを扱うもので、
丸括弧、角括弧、中括弧(使用言語において対応が取れている必要がある括弧)と、
それらをクォートするエスケープ文字だけに注目するコマンド群です。

@c   The other commands deal with expressions or @dfn{sexps}.  The word `sexp'
@c is derived from @dfn{s-expression}, the ancient term for an expression in
@c Lisp.  But in Emacs, the notion of `sexp' is not limited to Lisp.  It
@c refers to an expression in whatever language your program is written in.
@c Each programming language has its own major mode, which customizes the
@c syntax tables so that expressions in that language count as sexps.
もう一方は、式あるいは@dfn{S式}(sexp)を扱うコマンド群です。
「sexp」という用語は、
Lispの式を意味する古くからの用語@dfn{s-expression}に由来します。
Emacsでは「S式」の概念をLispに限定しません。
プログラムを記述した言語が何であっても、その式をS式と呼びます。
各プログラム言語には独自のメジャーモードがあり、
そこでは、その言語の式をS式とみなすように構文テーブルを調整してあります。

@c   Sexps typically include symbols, numbers, and string constants, as well
@c as anything contained in parentheses, brackets or braces.
一般にS式には、丸括弧、角括弧、中括弧に囲まれた部分だけでなく、
シンボル、数値、文字列定数も含まれます。

@c   In languages that use prefix and infix operators, such as C, it is not
@c possible for all expressions to be sexps.  For example, C mode does not
@c recognize @samp{foo + bar} as a sexp, even though it @emph{is} a C expression;
@c it recognizes @samp{foo} as one sexp and @samp{bar} as another, with the
@c @samp{+} as punctuation between them.  This is a fundamental ambiguity:
@c both @samp{foo + bar} and @samp{foo} are legitimate choices for the sexp to
@c move over if point is at the @samp{f}.  Note that @samp{(foo + bar)} is a
@c single sexp in C mode.
Cのように前置演算子と中置演算子を使う言語では、
すべての式をS式として扱うことは不可能です。
たとえば、Cモードでは、@samp{foo + bar}はCの式@emph{です}が、
S式としては認識しません。
かわりに、@samp{foo}と@samp{bar}をそれぞれ1つのS式として認識し、
@samp{+}はあいだにある句読点として認識します。
これは根本的に曖昧なのです。
たとえば、ポイントが@samp{f}にあるとき、横断すべきS式としては、
@samp{foo + bar}でも@samp{foo}でも正当な選択肢です。
@samp{(foo + bar)}は、Cモードにおいて単一のS式であることに注意してください。

@c   Some languages have obscure forms of expression syntax that nobody
@c has bothered to make Emacs understand properly.
式の構文が曖昧なために、
Emacsが正しく解釈できるようにしようなどとは誰も思わない言語もあります。

@node List Commands, Defuns, Lists, Programs
@c @section List And Sexp Commands
@section リストとS式に対するコマンド

@c doublewidecommands
@table @kbd
@item C-M-f
@c Move forward over a sexp (@code{forward-sexp}).
S式を横断して前向きに移動する(@code{forward-sexp})。
@item C-M-b
@c Move backward over a sexp (@code{backward-sexp}).
S式を横断して後向きに移動する(@code{backward-sexp})。
@item C-M-k
@c Kill sexp forward (@code{kill-sexp}).
前向きにS式をキルする(@code{kill-sexp})。
@item C-M-@key{DEL}
@c Kill sexp backward (@code{backward-kill-sexp}).
後向きにS式をキルする(@code{backward-kill-sexp})。
@item C-M-u
@c Move up and backward in list structure (@code{backward-up-list}).
リスト構造を1レベル上がって後向きに移動する(@code{backward-up-list})。
@item C-M-d
@c Move down and forward in list structure (@code{down-list}).
リスト構造を1レベル下がって前向きに移動する(@code{down-list})。
@item C-M-n
@c Move forward over a list (@code{forward-list}).
リストを横断して前向きに移動する(@code{forward-list})。
@item C-M-p
@c Move backward over a list (@code{backward-list}).
リストを横断して後向きに移動する(@code{backward-list})。
@item C-M-t
@c Transpose expressions (@code{transpose-sexps}).
式を入れ替える(@code{transpose-sexps})。
@item C-M-@@
@c Put mark after following expression (@code{mark-sexp}).
つぎの式の直後にマークを設定する(@code{mark-sexp})。
@end table

@kindex C-M-f
@kindex C-M-b
@findex forward-sexp
@findex backward-sexp
@c   To move forward over a sexp, use @kbd{C-M-f} (@code{forward-sexp}).  If
@c the first significant character after point is an opening delimiter
@c (@samp{(} in Lisp; @samp{(}, @samp{[} or @samp{@{} in C), @kbd{C-M-f}
@c moves past the matching closing delimiter.  If the character begins a
@c symbol, string, or number, @kbd{C-M-f} moves over that.
S式を横断して前向きに移動するには、
@kbd{C-M-f}(@code{forward-sexp})を使います。
ポイントに続く最初の意味ある文字が開き区切り
(Lisp では@samp{(}、Cでは@samp{(}や@samp{[}や@samp{@{})であれば、
対応する閉じ区切りのうしろに移動します。
シンボル、文字列、数値を始める文字の場合には、
それらを横断してその末尾に移動します。

@c   The command @kbd{C-M-b} (@code{backward-sexp}) moves backward over a
@c sexp.  The detailed rules are like those above for @kbd{C-M-f}, but with
@c directions reversed.  If there are any prefix characters (single-quote,
@c backquote and comma, in Lisp) preceding the sexp, @kbd{C-M-b} moves back
@c over them as well.  The sexp commands move across comments as if they
@c were whitespace in most modes.
コマンド@kbd{C-M-b}(@code{backward-sexp})は、
S式を横断して後向きに移動します。
移動の詳しい規則は上記の@kbd{C-M-f}と同様ですが、方向は逆です。
S式のまえに接頭辞文字(Lispではシングルクォート、バッククォート、コンマ)が
ある場合には、それらも横断します。
ほとんどのモードでは、S式コマンドはコメントを空白であるかのように
飛び越えます。

@c   @kbd{C-M-f} or @kbd{C-M-b} with an argument repeats that operation the
@c specified number of times; with a negative argument, it moves in the
@c opposite direction.
@kbd{C-M-f}や@kbd{C-M-b}に引数を指定すると、
指定された回数だけ動作を繰り返します。
負の引数では、逆向きに移動します。

@kindex C-M-k
@findex kill-sexp
@kindex C-M-DEL
@findex backward-kill-sexp
@c   Killing a whole sexp can be done with @kbd{C-M-k} (@code{kill-sexp})
@c or @kbd{C-M-@key{DEL}} (@code{backward-kill-sexp}).  @kbd{C-M-k} kills
@c the characters that @kbd{C-M-f} would move over, and @kbd{C-M-@key{DEL}}
@c kills the characters that @kbd{C-M-b} would move over.
1つのS式全体をキルするには、@kbd{C-M-k}(@code{kill-sexp})や
@kbd{C-M-@key{DEL}}(@code{backward-kill-sexp})で行います。
@kbd{C-M-k}は@kbd{C-M-f}で横断するだけの文字をキルし、
@kbd{C-M-@key{DEL}}は@kbd{C-M-b}で横断するだけの文字をキルします。

@kindex C-M-n
@kindex C-M-p
@findex forward-list
@findex backward-list
@c   The @dfn{list commands} move over lists, as the sexp commands do, but skip
@c blithely over any number of other kinds of sexps (symbols, strings, etc.).
@c They are @kbd{C-M-n} (@code{forward-list}) and @kbd{C-M-p}
@c (@code{backward-list}).  The main reason they are useful is that they
@c usually ignore comments (since the comments usually do not contain any
@c lists).@refill
S式コマンドと同様に、@dfn{リストコマンド}はリストを横断しますが、
リスト以外のS式(シンボルや文字列など)は飛び越します。
これらのコマンドは、@kbd{C-M-n}(@code{forward-list})と
@kbd{C-M-p}(@code{backward-list})です。
これらのコマンドが便利である主な理由は、
(コメントにはリストが何も含まれないのが普通なので)
コメントを無視するからです。

@kindex C-M-u
@kindex C-M-d
@findex backward-up-list
@findex down-list
@c   @kbd{C-M-n} and @kbd{C-M-p} stay at the same level in parentheses, when
@c that's possible.  To move @emph{up} one (or @var{n}) levels, use @kbd{C-M-u}
@c (@code{backward-up-list}).
@c @kbd{C-M-u} moves backward up past one unmatched opening delimiter.  A
@c positive argument serves as a repeat count; a negative argument reverses
@c direction of motion and also requests repetition, so it moves forward and
@c up one or more levels.@refill
@kbd{C-M-n}と@kbd{C-M-p}は、可能な限り同じレベルの括弧にとどまります。
1つ(あるいは@var{n}だけ)@emph{上の}レベルに移動するには、
@kbd{C-M-u}(@code{backward-up-list})を使います。
@kbd{C-M-u}は、対応の取れていない開き区切りのまえへ後向きに移動して、
1つレベルを上げます。
正の引数は反復回数になります。
負の引数は、移動を逆向きにしますが、やはり反復回数です。
つまり、前向きに移動して、1つ以上レベルを上げます。

@c   To move @emph{down} in list structure, use @kbd{C-M-d}
@c (@code{down-list}).  In Lisp mode, where @samp{(} is the only opening
@c delimiter, this is nearly the same as searching for a @samp{(}.  An
@c argument specifies the number of levels of parentheses to go down.
リスト構造中で@emph{下}のレベルに移動するには、
@kbd{C-M-d}(@code{down-list})を使います。
Lispモードでは、@samp{(}が唯一の開き区切りなので、
このコマンドは@samp{(}を探索するのとほとんど同じです。
引数は下がるべき括弧のレベルを指定します。

@c @cindex transposition
@cindex 入れ替え
@kindex C-M-t
@findex transpose-sexps
@c   A somewhat random-sounding command which is nevertheless handy is
@c @kbd{C-M-t} (@code{transpose-sexps}), which drags the previous sexp
@c across the next one.  An argument serves as a repeat count, and a
@c negative argument drags backwards (thus canceling out the effect of
@c @kbd{C-M-t} with a positive argument).  An argument of zero, rather than
@c doing nothing, transposes the sexps ending after point and the mark.
本当は役に立つのに、何の役に立つのだろうと思われるコマンドが
@kbd{C-M-t}(@code{transpose-sexps})です。
これはポイントのまえにあるS式を、つぎにあるS式を越えて移動するコマンドです。
引数は反復回数となり、負の引数では後向きにS式を移動します
(つまり正の引数を指定した@kbd{C-M-t}の効果を打ち消せる)。
引数が0の場合は、何もしないのではなくて、
ポイントのあとにあるS式とマークのあとにあるS式を入れ替えます。

@kindex C-M-@@
@findex mark-sexp
@c   To set the region around the next sexp in the buffer, use @kbd{C-M-@@}
@c (@code{mark-sexp}), which sets mark at the same place that @kbd{C-M-f}
@c would move to.  @kbd{C-M-@@} takes arguments like @kbd{C-M-f}.  In
@c particular, a negative argument is useful for putting the mark at the
@c beginning of the previous sexp.
バッファ内でつぎにあるS式の周りにリージョンを設定するには、
@kbd{C-M-@@}(@code{mark-sexp})を使います。
このコマンドは、@kbd{C-M-f}による移動先にマークを設定します。
@kbd{C-M-@@}は、@kbd{C-M-f}と同様に引数を取ります。
とりわけ、負の引数は、直前のS式の先頭にマークを設定するのに便利です。

@c   The list and sexp commands' understanding of syntax is completely
@c controlled by the syntax table.  Any character can, for example, be
@c declared to be an opening delimiter and act like an open parenthesis.
@c @xref{Syntax}.
リストおよびS式コマンドが行う構文の解釈は、
構文テーブルに完全に支配されます。
たとえば、任意の文字を開き区切りとして宣言できて、
そうすると開き括弧のようにふるまうようになります。
@xref{Syntax}。

@node Defuns, Program Indent, List Commands, Programs
@c @section Defuns
@section 関数定義(defun)
@c @cindex defuns
@cindex 関数定義(defun)
@cindex defun(関数定義)

@c   In Emacs, a parenthetical grouping at the top level in the buffer is
@c called a @dfn{defun}.  The name derives from the fact that most top-level
@c lists in a Lisp file are instances of the special form @code{defun}, but
@c any top-level parenthetical grouping counts as a defun in Emacs parlance
@c regardless of what its contents are, and regardless of the programming
@c language in use.  For example, in C, the body of a function definition is a
@c defun.
Emacsでは、トップレベルの括弧でグループ化したものは
@dfn{関数定義}(defun)と呼ばれます。
この名前は、Lispファイルではトップレベルにあるリストの大半が
スペシャルフォーム@code{defun}であるという事実に由来します。
しかし、その中身が何であろうとも、また、使用プログラム言語が何であろうとも、
Emacs流には、トップレベルの括弧でグループ化されたものは
すべて関数定義(defun)です。
たとえば、Cの関数定義の本体は関数定義(defun)です。

@c doublewidecommands
@table @kbd
@item C-M-a
@c Move to beginning of current or preceding defun
@c (@code{beginning-of-defun}).
現在の関数定義、あるいは、直前の関数定義の先頭に移動する
(@code{beginning-of-defun})。
@item C-M-e
@c Move to end of current or following defun (@code{end-of-defun}).
現在の関数定義、あるいは、つぎの関数定義の末尾に移動する
(@code{end-of-defun})。
@item C-M-h
@c Put region around whole current or following defun (@code{mark-defun}).
現在の関数定義、あるいは、つぎの関数定義を囲むリージョンを設定する
(@code{mark-defun})。
@end table

@kindex C-M-a
@kindex C-M-e
@kindex C-M-h
@findex beginning-of-defun
@findex end-of-defun
@findex mark-defun
@c   The commands to move to the beginning and end of the current defun are
@c @kbd{C-M-a} (@code{beginning-of-defun}) and @kbd{C-M-e} (@code{end-of-defun}).
現在の関数定義の先頭や末尾に移動するコマンドは、
@kbd{C-M-a}(@code{beginning-of-defun})と
@kbd{C-M-e}(@code{end-of-defun})です。

@findex c-mark-function
@c   If you wish to operate on the current defun, use @kbd{C-M-h}
@c (@code{mark-defun}) which puts point at the beginning and mark at the end
@c of the current or next defun.  For example, this is the easiest way to get
@c ready to move the defun to a different place in the text.  In C mode,
@c @kbd{C-M-h} runs the function @code{c-mark-function}, which is almost the
@c same as @code{mark-defun}; the difference is that it backs up over the
@c argument declarations, function name and returned data type so that the
@c entire C function is inside the region.  @xref{Marking Objects}.
現在の関数定義を操作したいのであれば、
@kbd{C-M-h}(@code{mark-defun})を使って、
現在の関数定義かつぎの関数定義の先頭にポイントを置き、
その末尾にマークを設定します。
たとえば、関数定義をテキストの別の位置に移動する準備をするには、
このコマンドを使うのがもっとも簡単な方法です。
Cモードでは、@kbd{C-M-h}は@code{c-mark-function}を実行しますが、
@code{mark-defun}とほとんど同じです。
違いは、引数宣言、関数名、戻り値の型名と遡って、
Cの関数全体をリージョンに含めることです。
@xref{Marking Objects}。

@c   Emacs assumes that any open-parenthesis found in the leftmost column
@c is the start of a defun.  Therefore, @strong{never put an
@c open-parenthesis at the left margin in a Lisp file unless it is the
@c start of a top-level list.  Never put an open-brace or other opening
@c delimiter at the beginning of a line of C code unless it starts the body
@c of a function.}  The most likely problem case is when you want an
@c opening delimiter at the start of a line inside a string.  To avoid
@c trouble, put an escape character (@samp{\}, in C and Emacs Lisp,
@c @samp{/} in some other Lisp dialects) before the opening delimiter.  It
@c will not affect the contents of the string.
Emacsは、もっとも左の桁でみつけた任意の開き括弧を
関数定義の始まりであると仮定します。
したがって、@strong{トップレベルのリストの始まりでない限り、
Lispファイルの中では左端に開き括弧を置いてはいけません。
また、関数本体の始まりを表すのでない限り、
Cのコードの行頭に開き中括弧や開き区切りを置いてはいけません。}
もっとも起こりやすい場面は、
文字列の途中で、行頭に開き区切りを入れたい場合です。
トラブルを避けるために、開き区切りのまえに
エスケープ文字(CやEmacs Lispでは @samp{\}、
その他のLisp方言のいくつかでは@samp{/})を入れてください。
これで文字列の内容が影響を受けることはありません。

@c   In the remotest past, the original Emacs found defuns by moving upward a
@c level of parentheses until there were no more levels to go up.  This always
@c required scanning all the way back to the beginning of the buffer, even for
@c a small function.  To speed up the operation, Emacs was changed to assume
@c that any @samp{(} (or other character assigned the syntactic class of
@c opening-delimiter) at the left margin is the start of a defun.  This
@c heuristic is nearly always right and avoids the costly scan; however,
@c it mandates the convention described above.
大昔のもともとのEmacsでは、関数定義を探すために、
より上位レベルの括弧がなくなるまで遡っていました。
この方法では、たとえ小さな関数であっても、
バッファの先頭まで遡って走査することがつねに必要でした。
これを高速化するために、左端内の任意の@samp{(}
(あるいは、開き区切りと宣言された任意の文字)が
関数定義の始まりであると仮定するように、Emacsを変更しました。
この発見的手法で、ほとんど正しく処理できて、時間のかかる走査を回避できます。
しかし、上述の約束事は必要です。

@node Program Indent, Matching, Defuns, Programs
@c @section Indentation for Programs
@section プログラムの字下げ
@c @cindex indentation for programs
@cindex プログラムの字下げ

@c   The best way to keep a program properly indented is to use Emacs to
@c reindent it as you change it.  Emacs has commands to indent properly
@c either a single line, a specified number of lines, or all of the lines
@c inside a single parenthetical grouping.
正しく字下げされた状態にプログラムを保つ最良の方法は、
変更したらEmacsに字下げをやり直させることです。
Emacsには、1行の字下げ、指定された行数の字下げ、あるいは、
括弧でグループ化した内部のすべての行の字下げを行うコマンドがあります。

@menu
* Basic Indent::	Indenting a single line.
* Multi-line Indent::   Commands to reindent many lines at once.
* Lisp Indent::		Specifying how each Lisp function should be indented.
* C Indent::		Extra features for indenting C and related modes.
* Custom C Indent::	Controlling indentation style for C and related modes.
@end menu

@c   Emacs also provides a Lisp pretty-printer in the library @code{pp}.
@c This program reformats a Lisp object with indentation chosen to look nice.
Emacsでは、ライブラリ@code{pp}にLispのプリティプリンタ@footnote{【訳注】
プログラムのソースコードを美しく清書するプログラムを
一般にプリティプリンタ(pretty-printer)と呼ぶ。}
もあります。
このプログラムは、美しく見えるように字下げを施してLispオブジェクトを
清書するプログラムです。

@node Basic Indent, Multi-line Indent, , Program Indent
@c @subsection Basic Program Indentation Commands
@subsection プログラムの字下げ基本コマンド

@c WideCommands
@table @kbd
@item @key{TAB}
@c Adjust indentation of current line.
現在行の字下げを調整する。
@item C-j
@c Equivalent to @key{RET} followed by @key{TAB} (@code{newline-and-indent}).
@key{RET}に続けて@key{TAB}と打鍵するのと同じ
(@code{newline-and-indent})。
@end table

@c @kindex TAB @r{(programming modes)}
@kindex TAB @r{(プログラミングモード)}
@findex c-indent-line
@findex lisp-indent-line
@c   The basic indentation command is @key{TAB}, which gives the current line
@c the correct indentation as determined from the previous lines.  The
@c function that @key{TAB} runs depends on the major mode; it is @code{lisp-indent-line}
@c in Lisp mode, @code{c-indent-line} in C mode, etc.  These functions
@c understand different syntaxes for different languages, but they all do
@c about the same thing.  @key{TAB} in any programming-language major mode
@c inserts or deletes whitespace at the beginning of the current line,
@c independent of where point is in the line.  If point is inside the
@c whitespace at the beginning of the line, @key{TAB} leaves it at the end of
@c that whitespace; otherwise, @key{TAB} leaves point fixed with respect to
@c the characters around it.
基本的な字下げコマンドは@key{TAB}です。
直前の数行から判断した正しい字下げを現在行に施します。
@key{TAB}が実行する関数は、メジャーモードに依存します。
たとえば、Lispモードでは@code{lisp-indent-line}、
Cモードでは@code{c-indent-line}が実行されます。
これらの関数はそれぞれの言語の構文を解釈しますが、
どれも同じことを行うためのものです。
プログラム言語向けメジャーモードにおいては、
@key{TAB}は、現在行のどこにポイントがあっても、
現在行の先頭に白文字を挿入したり削除したりします。
ポイントが行頭の白文字の中にあったときは、
@key{TAB}は最後の白文字のうしろにポイントを置きます。
そうでなければ、@key{TAB}を打ったときの文字のところに留まります。

@c   Use @kbd{C-q @key{TAB}} to insert a tab at point.
ポイント位置にタブを挿入するには、@kbd{C-q @key{TAB}}を使います。

@kindex C-j
@findex newline-and-indent
@c   When entering lines of new code, use @kbd{C-j} (@code{newline-and-indent}),
@c which is equivalent to a @key{RET} followed by a @key{TAB}.  @kbd{C-j} creates
@c a blank line and then gives it the appropriate indentation.
新たにソースコード行を入力するときには、
@kbd{C-j}(@code{newline-and-indent})を使ってください。
これは、@key{RET}に続けて@key{TAB}を打鍵することと等価です。
@kbd{C-j}は、空行を作ってから、その行で適切な字下げを行います。

@c   @key{TAB} indents the second and following lines of the body of a
@c parenthetical grouping each under the preceding one; therefore, if you
@c alter one line's indentation to be nonstandard, the lines below will
@c tend to follow it.  This behavior is convenient in cases where you have
@c overridden the standard result of @key{TAB} because you find it
@c unaesthetic for a particular line.
括弧でグループにまとめたところでは、
@key{TAB}は、2行目以降の行をそれぞれ直前の行の真下にくるように字下げします。
したがって、ある行を非標準的な字下げにすると、
以降の行もその字下げに従うことになります。
@key{TAB}による標準的な字下げが、
特定の行では美しくないので無視したい場合には、
字下げのこのようなふるまいが便利です。

@c   Remember that an open-parenthesis, open-brace or other opening delimiter
@c at the left margin is assumed by Emacs (including the indentation routines)
@c to be the start of a function.  Therefore, you must never have an opening
@c delimiter in column zero that is not the beginning of a function, not even
@c inside a string.  This restriction is vital for making the indentation
@c commands fast; you must simply accept it.  @xref{Defuns}, for more
@c information on this.
(字下げ処理を含めて)Emacsは、左端にある、開き丸括弧、開き中括弧、
および、その他の開き区切りを関数の始まりと仮定することを
覚えておきましょう。
たとえ文字列の中であっても、
関数の始まりでない開き区切りをけっして0桁目に置いてはいけません。
この制約は字下げコマンドを高速にするためにきわめて重要です。
無条件で受け入れてください。
これに関してより詳しくは、@xref{Defuns}。

@node Multi-line Indent, Lisp Indent, Basic Indent, Program Indent
@c @subsection Indenting Several Lines
@subsection 複数行の字下げ

@c   When you wish to reindent several lines of code which have been altered
@c or moved to a different level in the list structure, you have several
@c commands available.
変更した複数行や、リスト構造中の異なるレベル箇所へ移した複数の行を
字下げし直すには、いくつかのコマンドを利用できます。

@table @kbd
@item C-M-q
@c Reindent all the lines within one list (@code{indent-sexp}).
リスト内のすべての行を字下げし直す(@code{indent-sexp})。
@item C-u @key{TAB}
@c Shift an entire list rigidly sideways so that its first line
@c is properly indented.
リストの最初の行が正しい字下げ位置にくるように、
リストのすべての行を横にそのまま動かす。
@item C-M-\
@c Reindent all lines in the region (@code{indent-region}).
リージョン内のすべての行を字下げし直す(@code{indent-region})。
@end table

@kindex C-M-q
@findex indent-sexp
@c   You can reindent the contents of a single list by positioning point
@c before the beginning of it and typing @kbd{C-M-q} (@code{indent-sexp} in
@c Lisp mode, @code{c-indent-exp} in C mode; also bound to other suitable
@c commands in other modes).  The indentation of the line the sexp starts on
@c is not changed; therefore, only the relative indentation within the list,
@c and not its position, is changed.  To correct the position as well, type a
@c @key{TAB} before the @kbd{C-M-q}.
1つのリストの中身を字下げし直すには、
リストの始まり位置にポイントを置いて
@kbd{C-M-q}(Lispモードでは@code{indent-sexp}、
Cモードでは@code{c-indent-exp}、
他のモードでは適切なコマンドにバインドされている)と打ちます。
S式が始まる行の字下げは変化しません。
つまり、リスト内の相対的な字下げが変化するだけで、
リストの位置は変わりません。
リストの開始位置も直すには、@kbd{C-M-q}のまえに@key{TAB}を打ってください。

@kindex C-u TAB
@c   If the relative indentation within a list is correct but the
@c indentation of its first line is not, go to that line and type @kbd{C-u
@c @key{TAB}}.  @key{TAB} with a numeric argument reindents the current
@c line as usual, then reindents by the same amount all the lines in the
@c grouping starting on the current line.  In other words, it reindents the
@c whole grouping rigidly as a unit.  It is clever, though, and does not
@c alter lines that start inside strings, or C preprocessor lines when in C
@c mode.
リスト内の相対的な字下げは正しいけれども、
リストの開始行の字下げが正しくない場合には、
その行に移動して@kbd{C-u @key{TAB}}と打ちます。
@key{TAB}に数引数を指定すると、通常どおり現在行を字下げしてから、
その行から始まるリスト内のすべての行にも同じ量の字下げを加えます。
いいかえれば、グループ全体をひとまとめに字下げし直します。
ただし、このコマンドは賢くて、文字列の中の行は移動しませんし、
Cモードではプリプロセッサ行を移動しません。

@c   Another way to specify the range to be reindented is with the region.
@c The command @kbd{C-M-\} (@code{indent-region}) applies @key{TAB} to
@c every line whose first character is between point and mark.
字下げし直す範囲を指定するには、リージョンを使うこともできます。
コマンド@kbd{C-M-\}(@code{indent-region})は、
ポイントとマークのあいだに
行の先頭文字が含まれるすべての行について@key{TAB}を実行します。

@node Lisp Indent, C Indent, Multi-line Indent, Program Indent
@c @subsection Customizing Lisp Indentation
@subsection Lispの字下げのカスタマイズ
@c @cindex customizing Lisp indentation
@cindex Lispの字下げのカスタマイズ

@c   The indentation pattern for a Lisp expression can depend on the function
@c called by the expression.  For each Lisp function, you can choose among
@c several predefined patterns of indentation, or define an arbitrary one with
@c a Lisp program.
Lisp式に対する字下げの仕方を、
その式から呼ばれる関数と関係付けることができます。
各Lisp関数に対して、あらかじめ定義された字下げパターンの中から選んだり、
Lispプログラムで任意のものを定義したりできます。

@c   The standard pattern of indentation is as follows: the second line of the
@c expression is indented under the first argument, if that is on the same
@c line as the beginning of the expression; otherwise, the second line is
@c indented underneath the function name.  Each following line is indented
@c under the previous line whose nesting depth is the same.
字下げの標準パターンは、つぎのとおりです。
式の開始行に関数呼び出しの引数がある場合は、
最初の引数の直下に2行目がくるように字下げします。
それ以外の場合は、関数名の直下に2行目がくるように字下げします。
続く各行は、入れ子の深さが同じである行の字下げと同じになります。

@vindex lisp-indent-offset
@c   If the variable @code{lisp-indent-offset} is non-@code{nil}, it overrides
@c the usual indentation pattern for the second line of an expression, so that
@c such lines are always indented @code{lisp-indent-offset} more columns than
@c the containing list.
変数@code{lisp-indent-offset}が@code{nil}以外ならば、
式の2行目に対する通常の字下げパターンを無効にして、
式の開始桁からつねに@code{lisp-indent-offset}だけ字下げします。

@vindex lisp-body-indent
@c   The standard pattern is overridden for certain functions.  Functions
@c whose names start with @code{def} always indent the second line by
@c @code{lisp-body-indent} extra columns beyond the open-parenthesis
@c starting the expression.
標準パターンが使用されない関数もいくつかあります。
名前が@code{def}で始まる関数に対しては、
式を開始する開き括弧の桁位置に@code{lisp-body-indent}を加えた桁位置へ
2行目がくるように字下げします。

@c   The standard pattern can be overridden in various ways for individual
@c functions, according to the @code{lisp-indent-function} property of the
@c function name.  There are four possibilities for this property:
関数名の属性@code{lisp-indent-function}を変更すれば、
各関数ごとに標準パターン以外の字下げを施せます。
この属性が取りえる値にはつぎの4つがあります。

@table @asis
@item @code{nil}
@c This is the same as no property; the standard indentation pattern is used.
属性がないのと同じ。標準の字下げパターンを使用する。 
@item @code{defun}
@c The pattern used for function names that start with @code{def} is used for
@c this function also.
名前が@code{def}で始まる関数に用いる字下げパターンを使用する。
@c @item a number, @var{number}
@item 数値 @var{number}
@c The first @var{number} arguments of the function are
@c @dfn{distinguished} arguments; the rest are considered the @dfn{body}
@c of the expression.  A line in the expression is indented according to
@c whether the first argument on it is distinguished or not.  If the
@c argument is part of the body, the line is indented @code{lisp-body-indent}
@c more columns than the open-parenthesis starting the containing
@c expression.  If the argument is distinguished and is either the first
@c or second argument, it is indented @emph{twice} that many extra columns.
@c If the argument is distinguished and not the first or second argument,
@c the standard pattern is followed for that line.
関数の最初の@var{number}個の引数を@dfn{区別された}引数と呼び、
残りを式の@dfn{本体}と呼ぶ。
行の最初の引数が区別された引数かどうかによって、各行の字下げが異なる。
引数が本体の一部ならば、それを含んだ式を開始する開き括弧の桁位置に
@code{lisp-body-indent}を加えた桁位置へ字下げする。
引数が区別された引数で最初か2番目ならば、
@code{lisp-body-indent}の@emph{2倍}を加えた桁位置へ字下げする。
引数が区別された引数であっても3番目以降ならば、標準パターンを適用する。
@c @item a symbol, @var{symbol}
@item シンボル@var{symbol}
@c @var{symbol} should be a function name; that function is called to
@c calculate the indentation of a line within this expression.  The
@c function receives two arguments:
@var{symbol}は関数名であること。
この関数は、当該式の字下げ幅を計算する。
この関数はつぎの2つの引数を受け取る。
@table @asis
@item @var{state}
@c The value returned by @code{parse-partial-sexp} (a Lisp primitive for
@c indentation and nesting computation) when it parses up to the
@c beginning of this line.
当該行の先頭までを解析したときの@code{parse-partial-sexp}
(字下げと入れ子の計算を行うLispの基本的な関数)の戻り値。
@item @var{pos}
@c The position at which the line being indented begins.
字下げ対象の行の開始位置。
@end table
@noindent
@c It should return either a number, which is the number of columns of
@c indentation for that line, or a list whose car is such a number.  The
@c difference between returning a number and returning a list is that a
@c number says that all following lines at the same nesting level should
@c be indented just like this one; a list says that following lines might
@c call for different indentations.  This makes a difference when the
@c indentation is being computed by @kbd{C-M-q}; if the value is a
@c number, @kbd{C-M-q} need not recalculate indentation for the following
@c lines until the end of the list.
この関数は、当該行に対する字下げ幅の桁数、あるいは、
リストのcarがそのような数値であるリストを返す必要がある。
数値を返した場合は、括弧の入れ子レベルが同じ行に対しては
同じ字下げ幅を意味する。
リストを返した場合は、後続の行に対しては字下げ幅が異なる可能性を意味する。
このような差異は、@kbd{C-M-q}で字下げを計算するときに現れる。
数値が返された場合、@kbd{C-M-q}は、リストの末尾に達するまでは、
字下げの再計算を行う必要がない。
@end table

@node C Indent, Custom C Indent, Lisp Indent, Program Indent
@c @subsection Commands for C Indentation
@subsection Cの字下げコマンド

@c   Here are the commands for indentation in C mode and related modes:
ここでは、Cモードとその関連モードにおける字下げコマンドを紹介します。

@table @code
@item C-c C-q
@c @kindex C-c C-q @r{(C mode)}
@kindex C-c C-q @r{(Cモード)}
@findex c-indent-defun
@c Reindent the current top-level function definition or aggregate type
@c declaration (@code{c-indent-defun}).
現在のトップレベルの関数定義、あるいは、型宣言の集まりを字下げし直す
(@code{c-indent-defun})。

@item C-M-q
@c @kindex C-M-q @r{(C mode)}
@kindex C-M-q @r{(Cモード)}
@findex c-indent-exp
@c Reindent each line in the balanced expression that follows point
@c (@code{c-indent-exp}).  A prefix argument inhibits error checking and
@c warning messages about invalid syntax.
ポイントのうしろにある釣り合った式の中の各行を字下げし直す
(@code{c-indent-exp})。
前置引数を指定すると、
不正な構文に対する検査をせずに、警告メッセージも発しない。

@item @key{TAB}
@findex c-indent-command
@c Reindent the current line, and/or in some cases insert a tab character
@c (@code{c-indent-command}).
現在行を字下げし直すか、タブ文字を挿入する
(@code{c-indent-command})。

@c If @code{c-tab-always-indent} is @code{t}, this command always reindents
@c the current line and does nothing else.  This is the default.
@code{c-tab-always-indent}が@code{t}ならば、
現在行を字下げし直すだけで、他には何もしない。
これがデフォルト。

@c If that variable is @code{nil}, this command reindents the current line
@c only if point is at the left margin or in the line's indentation;
@c otherwise, it inserts a tab (or the equivalent number of spaces,
@c if @code{indent-tabs-mode} is @code{nil}).
この変数が@code{nil}ならば、
ポイントが左端か字下げの余白部分にある場合に限り、字下げし直す。
さもなければ、タブ
(あるいは、@code{indent-tabs-mode}が@code{nil}ならば、
等価な個数の空白)を挿入する。

@c Any other value (not @code{nil} or @code{t}) means always reindent the
@c line, and also insert a tab if within a comment, a string, or a
@c preprocessor directive.
上記の(@code{nil}や@code{t})以外の値であれば、通常どおり字下げし直す。
ただし、コメント、文字列、プリプロセッサ指令の内側では、タブを挿入する。

@item C-u @key{TAB}
@c Reindent the current line according to its syntax; also rigidly reindent
@c any other lines of the expression that starts on the current line.
@c @xref{Multi-line Indent}.
現在行の構文に従って現在行を字下げし直す。
なお、現在行から始まる式を構成する行も同じ幅だけ字下げし直す。
@pxref{Multi-line Indent}。
@end table

@c   To reindent the whole current buffer, type @kbd{C-x h C-M-\}.  This
@c first selects the whole buffer as the region, then reindents that
@c region.
カレントバッファ全体を字下げし直すには、
@kbd{C-x h C-M-\}と打ちます。
これは、まず、バッファ全体をリージョンとしてから、
そのリージョンを字下げし直します。

@c   To reindent the current block, use @kbd{C-M-u C-M-q}.  This moves
@c to the front of the block and then reindents it all.
カレントブロックを字下げし直すには、@kbd{C-M-u C-M-q}と打ちます。
これは、まず、ブロックの先頭に移動してから、
ブロック全体を字下げし直します。

@node Custom C Indent,  , C Indent, Program Indent
@c @subsection Customizing C Indentation
@subsection Cの字下げのカスタマイズ

@c   C mode and related modes use a simple yet flexible mechanism for
@c customizing indentation.  The mechanism works in two steps: first it
@c classifies the line syntactically according to its contents and context;
@c second, it associates each kind of syntactic construct with an
@c indentation offset which you can customize.
Cモードとその関連モードでは、字下げのカスタマイズには、
単純ですが柔軟性のある機構を用いています。
この機構は2段階で動作します。
まず、行をその内容と文脈から構文的に分類します。
つぎに、構文構成要素の各種類に、
カスタマイズ可能な字下げのオフセットを対応させます。

@menu
* Syntactic Analysis::
* Indentation Calculation::
* Changing Indent Style::
* Syntactic Symbols::
* Variables for C Indent::
* C Indent Styles::
@end menu

@node Syntactic Analysis, Indentation Calculation, , Custom C Indent
@c @subsubsection Step 1---Syntactic Analysis
@subsubsection 第1段階−−構文解析
@c @cindex syntactic analysis
@cindex 構文解析

@c   In the first step, the C indentation mechanism looks at the line
@c before the one you are currently indenting and determines the syntactic
@c components of the construct on that line.  It builds a list of these
@c syntactic components, each of which contains a @dfn{syntactic symbol}
@c and sometimes also a buffer position.  Some syntactic symbols describe
@c grammatical elements, for example @code{statement} and
@c @code{substatement}; others describe locations amidst grammatical
@c elements, for example @code{class-open} and @code{knr-argdecl}.
第1段階では、Cの字下げ機構は、字下げしようとしているまえの行を調べて、
その行を構成する構文上の構成要素を決定します。
つまり、@dfn{構文シンボル}とバッファ内の相対位置を要素とする
構文構成要素のリストを組み立てます。
構文シンボルには、@code{statement}(文)や
@code{substatement}(部分文)のように
文法要素を記述するものと、
@code{class-open}(クラス開始)や
@code{knr-argdecl}(K&R版引数宣言)のように文法要素のあいだの位置を
記述するものがあります。

@c   Conceptually, a line of C code is always indented relative to the
@c indentation of some line higher up in the buffer.  This is represented
@c by the buffer positions in the syntactic component list.
概念的には、Cのコード行は、バッファ中でそれよりまえに
あるいずれかの行に対して必ず相対的に字下げされます。
これは構文構成要素リストの中にあるバッファ内位置として表現されます。

@c   Here is an example.  Suppose we have the following code in a C++ mode
@c buffer (the line numbers don't actually appear in the buffer):
以下に例を示します。
つぎのコードが、C++モードのバッファに入っているとしましょう
(実際にバッファに行番号が表示されるわけではない)。

@example
1: void swap (int& a, int& b)
2: @{
3:   int tmp = a;
4:   a = b;
5:   b = tmp;
6: @}
@end example

@c   If you type @kbd{C-c C-s} (which runs the command
@c @code{c-show-syntactic-information}) on line 4, it shows the result of
@c the indentation mechanism for that line:
4行目で(@code{c-show-syntactic-information}を実行する)
@kbd{C-c C-s}を打つと、
その行に対する字下げ機構の結果が表示されます。

@example
((statement . 32))
@end example

@c   This indicates that the line is a statement and it is indented
@c relative to buffer position 32, which happens to be the @samp{i} in
@c @code{int} on line 3.  If you move the cursor to line 3 and type
@c @kbd{C-c C-s}, it displays this:
これは、その行が文であり、
バッファ内位置32に対して相対的に字下げされていることを示します。
バッファ内位置32は、3行目の@code{int}の@samp{i}にあたります。
カーソルを3行目に動かして@kbd{C-c C-s}と打つと、
今度はつぎのように表示されます。

@example
((defun-block-intro . 28))
@end example

@c   This indicates that the @code{int} line is the first statement in a
@c block, and is indented relative to buffer position 28, which is the
@c brace just after the function header.
この結果は、@code{int}行がブロックの最初の文であり、
バッファ内位置28に対して相対的に字下げされていることを示しています。
バッファ内位置28は、関数ヘッダの直後の中括弧にあたります。

@noindent
@c Here is another example:
別の例を見てみましょう。

@example
1: int add (int val, int incr, int doit)
2: @{
3:   if (doit)
4:     @{
5:       return (val + incr);
6:     @}
7:   return (val);
8: @}
@end example

@noindent
@c Typing @kbd{C-c C-s} on line 4 displays this:
4行目で@kbd{C-c C-s}と打つと、つぎのように表示されます。

@example
((substatement-open . 43))
@end example

@c   This says that the brace @emph{opens} a substatement block.  By the
@c way, a @dfn{substatement} indicates the line after an @code{if},
@c @code{else}, @code{while}, @code{do}, @code{switch}, @code{for},
@c @code{try}, @code{catch}, @code{finally}, or @code{synchronized}
@c statement.
これは、中括弧が部分文のブロックを@emph{始めて}いることを示しています。
ところで、@dfn{部分文}とは、@code{if}、@code{else}、@code{while}、
@code{do}、@code{switch}、@code{for}、@code{try}、@code{catch}、
@code{finally}、@code{synchronized}のあとの行を表します。

@c @cindex syntactic component
@c @cindex syntactic symbol
@cindex 構文構成要素
@cindex 構文シンボル
@vindex c-syntactic-context
@c   Within the C indentation commands, after a line has been analyzed
@c syntactically for indentation, the variable @code{c-syntactic-context}
@c contains a list that describes the results.  Each element in this list
@c is a @dfn{syntactic component}: a cons cell containing a syntactic
@c symbol and (optionally) its corresponding buffer position.  There may be
@c several elements in a component list; typically only one element has a
@c buffer position.
Cの字下げコマンドにおいては、
字下げのために行を構文解析し終えると、
変数@code{c-syntactic-context}には解析結果を表すリストが入ります。
このリストの各要素は@dfn{構文構成要素}であり、
構文シンボルと(省かれるかもしれない)対応するバッファ内位置の
コンスセルです。
構文構成要素リストには、複数の要素が含まれることもあります。
また、典型的には、バッファ内位置を持つ要素は1つだけです。

@node Indentation Calculation, Changing Indent Style, Syntactic Analysis, Custom C Indent
@c @subsubsection  Step 2---Indentation Calculation
@subsubsection  第2段階−−字下げ計算
@c @cindex Indentation Calculation
@cindex 字下げ計算

@c   The C indentation mechanism calculates the indentation for the current
@c line using the list of syntactic components, @code{c-syntactic-context},
@c derived from syntactic analysis.  Each component is a cons cell that
@c contains a syntactic symbol and may also contain a buffer position.
Cの字下げ機構は、構文解析で得られた構文構成要素リスト
@code{c-syntactic-context}を使って、現在行の字下げ幅を計算します。
このリストの各要素は、構文シンボルを含むコンスセルですが、
バッファ内位置を含んでいる場合もあります。

@c   Each component contributes to the final total indentation of the line
@c in two ways.  First, the syntactic symbol identifies an element of
@c @code{c-offsets-alist}, which is an association list mapping syntactic
@c symbols into indentation offsets.  Each syntactic symbol's offset adds
@c to the total indentation.  Second, if the component includes a buffer
@c position, the column number of that position adds to the indentation.
@c All these offsets and column numbers, added together, give the total
@c indentation.
リストの各要素は、最終的な総字下げ量に2つの方法で寄与します。
まず、各構文シンボルに字下げオフセットを対応付ける連想リスト
@code{c-offsets-alist}から要素を探すために構文シンボルが使われます。
各構文構成シンボルのオフセットを総字下げ量に加えます。
つぎに、リストの要素にバッファ内位置が含まれていれば、
その箇所の桁位置を字下げ量に加えます。
これらのオフセットと桁数をすべて加えることで、総字下げ量が求まります。

@c   The following examples demonstrate the workings of the C indentation
@c mechanism:
以下の例でCの字下げ機構の動作を説明しましょう。

@example
1: void swap (int& a, int& b)
2: @{
3:   int tmp = a;
4:   a = b;
5:   b = tmp;
6: @}
@end example

@c   Suppose that point is on line 3 and you type @key{TAB} to reindent the
@c line.  As explained above (@pxref{Syntactic Analysis}), the syntactic
@c component list for that line is:
3行目にポイントがあって、そこで@key{TAB}と打って字下げし直すとしましょう。
上(@pxref{Syntactic Analysis})でも説明しましたが、
その行に対する構文構成要素リストはつぎのようになります。

@example
((defun-block-intro . 28))
@end example

@c   In this case, the indentation calculation first looks up
@c @code{defun-block-intro} in the @code{c-offsets-alist} alist.  Suppose
@c that it finds the integer 2; it adds this to the running total
@c (initialized to zero), yielding a updated total indentation of 2 spaces.
ここでは、まず、連想リスト@code{c-offsets-alist}から
@code{defun-block-intro}を探すことから始めます。
その結果が整数値2であったとしましょう。
この値を計算中の合計(0で初期化されている)に加えて、
総字下げ量は空白2文字と更新されます。

@c   The next step is to find the column number of buffer position 28.
@c Since the brace at buffer position 28 is in column zero, this adds 0 to
@c the running total.  Since this line has only one syntactic component,
@c the total indentation for the line is 2 spaces.
つぎの段階は、バッファ内位置28の桁位置を求めることです。
バッファ内位置28の中括弧は0桁目にあるので、
0を計算中の合計に加えます。
3行目には構文要素が1つしかないので、総字下げ量は空白2文字となります。

@example
1: int add (int val, int incr, int doit)
2: @{
3:   if (doit)
4:     @{
5:       return(val + incr);
6:     @}
7:   return(val);
8: @}
@end example

@c   If you type @key{TAB} on line 4, the same process is performed, but
@c with different data.  The syntactic component list for this line is:
4行目で@key{TAB}と打つと、同じ過程を繰り返しますが、
異なる値を使って計算されます。
この行に対する構文構成要素リストはつぎのとおりです。

@example
((substatement-open . 43))
@end example

@c    Here, the indentation calculation's first job is to look up the
@c symbol @code{substatement-open} in @code{c-offsets-alist}.  Let's assume
@c that the offset for this symbol is 2.  At this point the running total
@c is 2 (0 + 2 = 2).  Then it adds the column number of buffer position 43,
@c which is the @samp{i} in @code{if} on line 3.  This character is in
@c column 2 on that line.  Adding this yields a total indentation of 4
@c spaces.
まずは、シンボル@code{substatement-open}を連想リスト
@code{c-offsets-alist}から探します。
このシンボルに対するオフセットが2であったとしましょう。
この時点で計算中の合計は2(0 + 2 = 2)です。
つぎに、バッファ内位置43(3行目の@code{if}の@samp{i}の位置)の
桁位置2を加えます。
結果として、空白4文字という総字下げ量が求まります。

@vindex c-strict-syntax-p
@c    If a syntactic symbol in the analysis of a line does not appear in
@c @code{c-offsets-alist}, it is ignored; if in addition the variable
@c @code{c-strict-syntax-p} is non-@code{nil}, it is an error.
行を解析した結果、@code{c-offsets-alist}に現れない構文シンボルが
みつかった場合、そのシンボルは無視します。
しかし、変数@code{c-strict-syntax-p}が@code{nil}以外の値であれば、
エラーを報告します。

@node Changing Indent Style, Syntactic Symbols, Indentation Calculation, Custom C Indent
@c @subsubsection Changing Indentation Style
@subsubsection 字下げスタイルの変更

@c    There are two ways to customize the indentation style for the C-like
@c modes.  First, you can select one of several predefined styles, each of
@c which specifies offsets for all the syntactic symbols.  For more
@c flexibility, you can customize the handling of individual syntactic
@c symbols.  @xref{Syntactic Symbols}, for a list of all defined syntactic
@c symbols.
C流のモードの字下げをカスタマイズする方法は2つあります。
1つは、あらかじめ定義されているスタイルから選択する方法です。
それぞれのスタイルでは、各構文シンボルに対するオフセットが定められています。
もう1つはより柔軟な方法で、各構文シンボルの扱い方をカスタマイズできます。
定義されている構文シンボルの一覧については、@xref{Syntactic Symbols}。

@table @kbd
@item M-x c-set-style @key{RET} @var{style} @key{RET}
@c Select predefined indentation style @var{style}.  Type @kbd{?} when
@c entering @var{style} to see a list of supported styles; to find out what
@c a style looks like, select it and reindent some C code.
あらかじめ定義されている字下げスタイル@var{style}を選択する。
@var{style}を入力する際に@kbd{?}と打てば、
定義済みのスタイル一覧を見ることができる。
スタイルの見栄えを調べるには、
そのスタイルを選択して、適当なCのコードを字下げし直してみる。

@item C-c C-o @var{symbol} @key{RET} @var{offset} @key{RET}
@c Set the indentation offset for syntactic symbol @var{symbol}
@c (@code{c-set-offset}).  The second argument @var{offset} specifies the
@c new indentation offset.
構文シンボル@var{symbol}に対する字下げのオフセットを設定する
(@code{c-set-offset})。
2番目の引数@var{offset}で、字下げのオフセットを指定する。
@end table

@c    The @code{c-offsets-alist} variable controls the amount of
@c indentation to give to each syntactic symbol.  Its value is an
@c association list, and each element of the list has the form
@c @code{(@var{syntactic-symbol} . @var{offset})}.  By changing the offsets
@c for various syntactic symbols, you can customize indentation in fine
@c detail.  To change this alist, use @code{c-set-offset} (see below).
変数@code{c-offsets-alist}は、各構文シンボルに与える字下げ量を制御します。
この変数の値は連想リストであり、
各要素は@code{(@var{syntactic-symbol} . @var{offset})}の形をしています。
さまざまな構文シンボルに対するオフセットを変えることで、
字下げを細かくカスタマイズできます。
連想リストを変更するには、@code{c-set-offset}を使います(下記参照)。 

@c    Each offset value in @code{c-offsets-alist} can be an integer, a
@c function or variable name, a list, or one of the following symbols: @code{+},
@c @code{-}, @code{++}, @code{--}, @code{*}, or @code{/}, indicating positive or negative
@c multiples of the variable @code{c-basic-offset}.  Thus, if you want to
@c change the levels of indentation to be 3 spaces instead of 2 spaces, set
@c @code{c-basic-offset} to 3.
@code{c-offsets-alist}内の各オフセットには、
整数、関数名や変数名、あるいは、
変数@code{c-basic-offset}の値の正負の倍数を表すシンボルである
@code{+}、@code{-}、@code{++}、@code{--}、@code{*}、
@code{/}のいずれかを設定できます。
したがって、基本の字下げ幅を空白2文字から3文字に変更したければ、
@code{c-basic-offset}に3を設定します。

@c    Using a function as the offset value provides the ultimate flexibility
@c in customizing indentation.  The function is called with a single
@c argument containing the @code{cons} of the syntactic symbol and
@c the buffer position, if any.  The function should return an integer
@c offset.
オフセットに関数を用いると、
字下げのカスタマイズに究極の柔軟性を持たせられます。
この関数は、構文シンボルとバッファ内位置があればそれを@code{cons}したものを
引数として呼ばれます。
戻り値としては、整数値のオフセットを返す必要があります。
  
@c    If the offset value is a list, its elements are processed according
@c to the rules above until a non-@code{nil} value is found.  That value is
@c then added to the total indentation in the normal manner.  The primary
@c use for this is to combine the results of several functions.
オフセットの値がリストの場合、
各要素は、@code{nil}以外の値がみつかるまで上の規則にしたがって処理されます。
その後、その値は、通常のように、字下げの総量に加えられます。
これは、主に、複数の関数の結果を組み合わせるために使われます。

@c @kindex C-c C-o @r{(C mode)}
@kindex C-c C-o @r{(Cモード)}
@findex c-set-offset
@c    The command @kbd{C-c C-o} (@code{c-set-offset}) is the easiest way to
@c set offsets, both interactively or in your @file{~/.emacs} file.  First
@c specify the syntactic symbol, then the offset you want.  @xref{Syntactic
@c Symbols}, for a list of valid syntactic symbols and their meanings.
対話的に設定するにしてもファイル@file{~/.emacs}で設定するにしても、
オフセットを設定するもっとも簡単な方法は、
コマンド@kbd{C-c C-o}(@code{c-set-offset})を使うことです。
最初の引数は構文シンボル、2番目の引数は希望のオフセットです。
有効な構文シンボル名とその意味の一覧は、@xref{Syntactic Symbols}。

@node Syntactic Symbols, Variables for C Indent, Changing Indent Style, Custom C Indent
@c @subsubsection Syntactic Symbols
@subsubsection 構文シンボル

@c    Here is a table of valid syntactic symbols for indentation in C and
@c related modes, with their syntactic meanings.  Normally, most of these
@c symbols are assigned offsets in @code{c-offsets-alist}.
Cモードや関連するモードの字下げに対して有効な構文シンボルを、
構文上の意味とともに、以下に示します。
これらのほとんどのシンボルには、
@code{c-offsets-alist}でオフセットが与えられています。

@table @code
@item string
@c Inside a multi-line string.
複数行におよぶ文字列の内側。

@item c
@c Inside a multi-line C style block comment.
複数行におよぶCスタイルのブロックコメントの内側。

@item defun-open
@c On a brace that opens a function definition.
関数定義を開始する中括弧。

@item defun-close
@c On a brace that closes a function definition.
関数定義を終了する中括弧。

@item defun-block-intro
@c In the first line in a top-level defun.
トップレベルの関数定義の最初の行。

@item class-open
@c On a brace that opens a class definition.
クラス定義を開始する中括弧。

@item class-close
@c On a brace that closes a class definition.
クラス定義を終了する中括弧。

@item inline-open
@c On a brace that opens an in-class inline method.
クラス内のインラインメソッドを開始する中括弧。

@item inline-close
@c On a brace that closes an in-class inline method.
クラス内のインラインメソッドを終了する中括弧。

@item extern-lang-open
@c On a brace that opens an external language block.
外部言語ブロックを開始する中括弧。

@item extern-lang-close
@c On a brace that closes an external language block.
外部言語ブロックを終了する中括弧。

@item func-decl-cont
@c The region between a function definition's argument list and the defun
@c opening brace (excluding K&R function definitions).  In C, you cannot
@c put anything but whitespace and comments between them; in C++ and Java,
@c @code{throws} declarations and other things can appear in this context.
関数定義の引数リストと関数定義の本体を開始する中括弧のあいだの領域。
ただし、K&R版の関数定義を除く。
Cでは、この部分に空文字やコメント以外は置けない。
C++やJavaでは、@code{throws}宣言などを置ける。

@item knr-argdecl-intro
@c On the first line of a K&R C argument declaration.
K&R版Cの引数宣言の最初の行。

@item knr-argdecl
@c In one of the subsequent lines in a K&R C argument declaration.
K&R版Cの引数宣言の2行目以降。

@item topmost-intro
@c On the first line in a topmost construct definition.
最上位の言語構成要素の最初の行。

@item topmost-intro-cont
@c On the topmost definition continuation lines.
最上位の言語構成要素の2行目以降。

@item member-init-intro
@c On the first line in a member initialization list.
(構造体の)メンバ初期化リストの最初の行。

@item member-init-cont
@c On one of the subsequent member initialization list lines.
(構造体の)メンバ初期化リストの2行目以降。

@item inher-intro
@c On the first line of a multiple inheritance list.
多重継承リストの最初。

@item inher-cont
@c On one of the subsequent multiple inheritance lines.
多重継承リストの2行目以降。

@item block-open
@c On a statement block open brace.
文ブロックを開始する中括弧。

@item block-close
@c On a statement block close brace.
文ブロックを終了する中括弧。

@item brace-list-open
@c On the opening brace of an @code{enum} or @code{static} array list.
@code{enum}のリストや静的配列の初期化リストを開始する中括弧。

@item brace-list-close
@c On the closing brace of an @code{enum} or @code{static} array list.
@code{enum}のリストや静的配列の初期化リストを終了する中括弧。

@item brace-list-intro
@c On the first line in an @code{enum} or @code{static} array list.
@code{enum}のリストや静的配列の初期化リストの最初の行。

@item brace-list-entry
@c On one of the subsequent lines in an @code{enum} or @code{static} array
@c list.
@code{enum}のリストや静的配列の初期化リストの2行目以降。

@item brace-entry-open
@c On one of the subsequent lines in an @code{enum} or @code{static} array
@c list, when the line begins with an open brace.
行が開き中括弧で始まるときの、
@code{enum}のリストや静的配列の初期化リストの2行目以降。

@item statement
@c On an ordinary statement.
通常の文。

@item statement-cont
@c On a continuation line of a statement.
文の継続行。

@item statement-block-intro
@c On the first line in a new statement block.
新規文ブロックの最初の行。

@item statement-case-intro
@c On the first line in a @code{case} ``block.''
@code{case}ブロックの最初の行。

@item statement-case-open
@c On the first line in a @code{case} block starting with brace.
中括弧で始まる@code{case}ブロックの最初の行。

@item inexpr-statement
@c On a statement block inside an expression.  This is used for a GNU
@c extension to the C language, and for Pike special functions that take a
@c statement block as an argument.
式の内側にある文ブロック。
これは、C言語のGNU拡張や、
文ブロックを引数としてとるPikeの特殊関数に用いる。

@item inexpr-class
@c On a class definition inside an expression.  This is used for anonymous
@c classes and anonymous array initializers in Java.
式の内側にあるクラス定義。
これは、Javaの無名クラスや無名配列の初期化式に用いる。

@item substatement
@c On the first line after an @code{if}, @code{while}, @code{for},
@c @code{do}, or @code{else}.
@code{if}、@code{while}、@code{for}、
@code{do}、@code{else}の直後の最初の行

@item substatement-open
@c On the brace that opens a substatement block.
substatementのブロックを開始する中括弧。

@item case-label
@c On a @code{case} or @code{default} label.
@code{case}または@code{default}ラベルを表す。

@item access-label
@c On a C++ @code{private}, @code{protected}, or @code{public} access label.
C++のアクセス指定子@code{private}、@code{protected}、@code{public}を表す。

@item label
@c On any ordinary label.
通常のラベル。

@item do-while-closure
@c On the @code{while} that ends a @code{do}-@code{while} construct.
@code{do}-@code{while}文の@code{while}。

@item else-clause
@c On the @code{else} of an @code{if}-@code{else} construct.
@code{if}-@code{else}文の@code{else}。

@item catch-clause
@c On the @code{catch} and @code{finally} lines in
@c @code{try}@dots{}@code{catch} constructs in C++ and Java.
C++やJavaの@code{try}@dots{}@code{catch}構成の
@code{catch}行や@code{finally}行。

@item comment-intro
@c On a line containing only a comment introduction.
コメントの導入部分だけを含んだ行。

@item arglist-intro
@c On the first line in an argument list.
引数リストの最初の行。

@item arglist-cont
@c On one of the subsequent argument list lines when no arguments follow on
@c the same line as the arglist opening parenthesis.
引数リストを開始する括弧の行に引数がない場合、
引数リストの2行目以降。

@item arglist-cont-nonempty
@c On one of the subsequent argument list lines when at least one argument
@c follows on the same line as the arglist opening parenthesis.
引数リストを開始する括弧の行に少なくとも1つの引数がある場合、
引数リストの2行目以降。

@item arglist-close
@c On the closing parenthesis of an argument list.
引数リストを終了する括弧。

@item stream-op
@c On one of the lines continuing a stream operator construct.
ストリーム演算子を用いた式が継続する行。

@item inclass
@c On a construct that is nested inside a class definition.  The
@c indentation is relative to the open brace of the class definition.
クラス定義の内側に入れ子になった言語構成要素。
字下げは、クラス定義の開き中括弧に相対である。

@item inextern-lang
@c On a construct that is nested inside an external language block.
外部言語ブロックの内側に入れ子になった言語構成要素。

@item inexpr-statement
@c On the first line of statement block inside an expression.  This is used
@c for the GCC extension to C that uses the syntax @code{(@{ @dots{} @})}.
@c It is also used for the special functions that takes a statement block
@c as an argument in Pike.
式の内側の文ブロックの最初の行。
これは、構文@code{(@{ @dots{} @})}を使うCに対するGCC拡張に用いる。
文ブロックを引数としてとるPikeの特殊関数にも用いる。

@item inexpr-class
@c On the first line of a class definition inside an expression.  This is
@c used for anonymous classes and anonymous array initializers in Java.
式の内側のクラス定義の最初の行。
これは、Javaの無名クラスや無名配列の初期化式に用いる。

@item cpp-macro
@c On the start of a cpp macro.
cppマクロの開始。

@item friend
@c On a C++ @code{friend} declaration.
C++の@code{friend}宣言。

@item objc-method-intro
@c On the first line of an Objective-C method definition.
Objective-Cのメソッド定義の最初の行。

@item objc-method-args-cont
@c On one of the lines continuing an Objective-C method definition.
Objective-Cのメソッド定義を継続する行。

@item objc-method-call-cont
@c On one of the lines continuing an Objective-C method call.
Objective-Cのメソッド呼び出しを継続する行。

@item inlambda
@c Like @code{inclass}, but used inside lambda (i.e. anonymous) functions.  Only
@c used in Pike.
@code{inclass}と同様だが、ラムダ(つまり、無名)関数の内側に用いる。
Pikeのみで用いる。

@item lambda-intro-cont
@c On a line continuing the header of a lambda function, between the
@c @code{lambda} keyword and the function body.  Only used in Pike.
キーワード@code{lambda}と関数本体のあいだの、
ラムダ関数のヘッダーの継続行。
Pikeのみで用いる。
@end table

@node Variables for C Indent, C Indent Styles, Syntactic Symbols, Custom C Indent
@c @subsubsection Variables for C Indentation
@subsubsection Cの字下げのための変数

@c   This section describes additional variables which control the
@c indentation behavior of C mode and related mode.
本節では、Cモードとその関連モードの字下げ動作を制御する、
モードに固有な変数について説明します。

@table @code
@item c-offsets-alist
@vindex c-offsets-alist
@c Association list of syntactic symbols and their indentation offsets.
@c You should not set this directly, only with @code{c-set-offset}.
@c @xref{Changing Indent Style}, for details.
構文シンボルとその字下げオフセットの連想リスト。
このリストに直接に値を設定するのではなく、
@code{c-set-offset}を使うこと。
詳細については、@pxref{Changing Indent Style}。

@item c-style-alist
@vindex c-style-alist
@c Variable for defining indentation styles; see below.
字下げスタイルを定義している変数。
下記参照。

@item c-basic-offset
@vindex c-basic-offset
@c Amount of basic offset used by @code{+} and @code{-} symbols in
@c @code{c-offsets-alist}.@refill 
@code{c-offsets-alist}の中で、
シンボル@code{+}や@code{-}が用いるオフセットの基本量。

@item c-special-indent-hook
@vindex c-special-indent-hook
@c Hook for user-defined special indentation adjustments.  This hook is
@c called after a line is indented by C mode and related modes.
ユーザー定義の特別な字下げ調整用のフック。
このフックは、Cモードやその関連モードが行の字下げを終えたあとに呼ばれる。
@end table

@c   The variable @code{c-style-alist} specifies the predefined indentation
@c styles.  Each element has form @code{(@var{name}
@c @var{variable-setting}@dots{})}, where @var{name} is the name of the
@c style.  Each @var{variable-setting} has the form @code{(@var{variable}
@c . @var{value})}; @var{variable} is one of the customization variables
@c used by C mode, and @var{value} is the value for that variable when
@c using the selected style.
変数@code{c-style-alist}は、
あらかじめ定義された字下げスタイルを保持します。
各要素は@code{(@var{name} @var{variable-setting}@dots{})}の形をしていて、
@var{name}はスタイル名です。
また、各@var{variable-setting}は、
@code{(@var{variable} . @var{value})}の形をしています。
@var{variable}には、Cモードが使用するカスタマイズ用変数の1つを指定します。
@var{value}は、選択されたスタイルが使われるときの@var{variable}の値です。

@c   When @var{variable} is @code{c-offsets-alist}, that is a special case:
@c @var{value} is appended to the front of the value of @code{c-offsets-alist}
@c instead of replacing that value outright.  Therefore, it is not necessary
@c for @var{value} to specify each and every syntactic symbol---only those
@c for which the style differs from the default.
@var{variable}が@code{c-offsets-alist}である場合は、特殊なケースです。
@code{c-offsets-alist}の値を@var{value}の値で置き換えるのではなく、
@code{c-offsets-alist}の値の先頭に@var{value}を追加します。
したがって、@var{value}にすべての構文シンボルを設定する必要はありません。
デフォルトと異なる構文シンボルだけを単に設定すればよいのです。

@c   The indentation of lines containing only comments is also affected by
@c the variable @code{c-comment-only-line-offset} (@pxref{Comments in C}).
コメントだけを含んだ行の字下げも、
変数@code{c-comment-only-line-offset}
(@pxref{Comments in C})に影響されます。

@node C Indent Styles,  , Variables for C Indent, Custom C Indent
@c @subsubsection C Indentation Styles
@subsubsection Cの字下げスタイル
@c @cindex c indentation styles
@cindex Cの字下げスタイル

@c   A @dfn{C style} is a collection of indentation style customizations.
@c Emacs comes with several predefined indentation styles for C and related
@c modes, including @code{gnu}, @code{k&r}, @code{bsd}, @code{stroustrup},
@c @code{linux}, @code{python}, @code{java}, @code{whitesmith},
@c @code{ellemtel}, and @code{cc-mode}.  The default style is @code{gnu}.
@dfn{Cスタイル}とは、カスタマイズされた字下げスタイルの集合です。
Emacsには、Cモードや関連するモードのためにあらかじめ定義された、
@code{gnu}、@code{k&r}、@code{bsd}、@code{stroustrup}、
@code{linux}、@code{python}、@code{java}、@code{whitesmith}、
@code{ellemtel}、@code{cc-mode}といった字下げスタイルがあります。
デフォルトのスタイルは@code{gnu}です。

@findex c-set-style
@vindex c-default-style
@c   To choose the style you want, use the command @kbd{M-x c-set-style}.
@c Specify a style name as an argument (case is not significant in C style
@c names).  The chosen style only affects newly visited buffers, not those
@c you are already editing.  You can also set the variable
@c @code{c-default-style} to specify the style for various major modes.
@c Its value should be an alist, in which each element specifies one major
@c mode and which indentation style to use for it.  For example,
望みのスタイルを選択するには、コマンド@kbd{M-x c-set-style}を使います。
引数としてスタイル名を指定します
(Cスタイル名では大文字小文字は区別しない)。
選択したスタイルは新たに訪問したバッファにだけ影響し、
すでに編集中のバッファには影響しません。
さまざまなメジャーモードのスタイルを指定するために
変数@code{c-default-style}を設定することもできます。
その値は連想リストである必要があり、
その各要素は、1つのメジャーモードと
そのモードで使う字下げスタイルを指定します。
たとえば、

@example
(setq c-default-style
      '((java-mode . "java") (other . "gnu")))
@end example

@noindent
@c specifies an explicit choice for Java mode, and the default @samp{gnu}
@c style for the other C-like modes.
は、Javaモードには対しては選択を明示し、
他のC流モードには@samp{gnu}をデフォルトとします。

@findex c-add-style
@c   To define a new C indentation style, call the function
@c @code{c-add-style}:
Cの字下げスタイルを新たに定義するには、関数@code{c-add-style}を呼びます。

@example
(c-add-style @var{name} @var{values} @var{use-now})
@end example

@noindent
@c Here @var{name} is the name of the new style (a string), and
@c @var{values} is an alist whose elements have the form
@c @code{(@var{variable} . @var{value})}.  The variables you specify should
@c be among those documented in @ref{Variables for C Indent}.
ここで、@var{name}は新しいスタイルの名前(文字列)、
@var{values}は要素が@code{(@var{variable} . @var{value})}の形をした
連想リストです。
@var{variable}には、@ref{Variables for C Indent}に
書かれているものを指定してください。

@c If @var{use-now} is non-@code{nil}, @code{c-add-style} switches to the
@c new style after defining it.
@var{use-now}が@code{nil}以外ならば、
新しいスタイルの定義後すぐにそれに切り替えます。

@node Matching, Comments, Program Indent, Programs
@c @section Automatic Display Of Matching Parentheses
@section 対応している括弧の自動表示
@c @cindex matching parentheses
@c @cindex parentheses
@cindex 対応している括弧
@cindex 括弧

@c   The Emacs parenthesis-matching feature is designed to show
@c automatically how parentheses match in the text.  Whenever you type a
@c self-inserting character that is a closing delimiter, the cursor moves
@c momentarily to the location of the matching opening delimiter, provided
@c that is on the screen.  If it is not on the screen, some text near it is
@c displayed in the echo area.  Either way, you can tell what grouping is
@c being closed off.
Emacsの括弧の対応付け機能は、テキスト中でどのように括弧が
対応しているか自動的に表示するよう設計されています。
閉じ区切りである自己挿入文字を打つと、
それに対応する開き区切りが画面上にあれば、
その箇所にほんのしばらくカーソルが移動します。
画面上になければ、エコー領域にその箇所の近くにある文字列を表示します。
いずれにしても、1つのまとまりが閉じたことが判ります。

@c   In Lisp, automatic matching applies only to parentheses.  In C, it
@c applies to braces and brackets too.  Emacs knows which characters to regard
@c as matching delimiters based on the syntax table, which is set by the major
@c mode.  @xref{Syntax}.
Lispでは、括弧だけに対して自動的な対応付けを行います。
Cでは、中括弧や角括弧も対象となります。
Emacsは、メジャーモードが設定する構文テーブルに基づいて、
どの文字が対応関係にある区切りであるか判定します。
@xref{Syntax}。

@c   If the opening delimiter and closing delimiter are mismatched---such as
@c in @samp{[x)}---a warning message is displayed in the echo area.  The
@c correct matches are specified in the syntax table.
@samp{[x)}のように、開き区切りと閉じ区切りが対応しない場合、
エコー領域に警告メッセージを表示します。
正しい対応関係は構文テーブルで指定します。

@vindex blink-matching-paren
@vindex blink-matching-paren-distance
@vindex blink-matching-delay
@c   Three variables control parenthesis match display.
@c @code{blink-matching-paren} turns the feature on or off; @code{nil}
@c turns it off, but the default is @code{t} to turn match display on.
@c @code{blink-matching-delay} says how many seconds to wait; the default
@c is 1, but on some systems it is useful to specify a fraction of a
@c second.  @code{blink-matching-paren-distance} specifies how many
@c characters back to search to find the matching opening delimiter.  If
@c the match is not found in that far, scanning stops, and nothing is
@c displayed.  This is to prevent scanning for the matching delimiter from
@c wasting lots of time when there is no match.  The default is 12,000.
括弧の対応表示を制御する変数は3つあります。
@code{blink-maching-paren}は、対応表示機能をオンまたはオフにします。
@code{nil}を設定すると対応表示機能はオフになりますが、
デフォルトは@code{t}であり、対応表示を行います。
@code{blink-matching-delay}は、対応表示のために待つ秒数を指定します。
デフォルトは1秒ですが、システムによっては何分の1秒のほうが便利かもしれません。
@code{blink-matching-paren-distance}は、
対応している開き区切りをみつけるために、
何文字分まで戻って探索するか指定します。
その範囲内で対応するものがみつからなければ、走査をやめて何も表示しません。
これは、存在しもしない対応する区切りを探すことに
時間を浪費するのを防ぐためです。
デフォルトは12,000です。

@c @cindex Show Paren mode
@cindex 対応括弧表示(Show Paren)モード
@cindex show-parenモード
@cindex モード、Show Paren
@findex show-paren-mode
@c   When using X Windows, you can request a more powerful alternative kind
@c of automatic parenthesis matching by enabling Show Paren mode.  This
@c mode turns off the usual kind of matching parenthesis display and
@c instead uses highlighting to show what matches.  Whenever point is after
@c a close parenthesis, the close parenthesis and its matching open
@c parenthesis are both highlighted; otherwise, if point is before an open
@c parenthesis, the matching close parenthesis is highlighted.  (There is
@c no need to highlight the open parenthesis after point because the cursor
@c appears on top of that character.)  Use the command @kbd{M-x
@c show-paren-mode} to enable or disable this mode.
Xウィンドウシステムを使用している場合、
対応括弧表示(show-paren)モードにすれば、
より強力な括弧の対応表示を利用できます。
このモードは、通常の対応表示をオフにするかわりに、
対応する括弧同士を示すために強調表示を行います。
ポイントが閉じ括弧の直後にあるときには、
閉じ括弧とそれに対応する開き括弧の両方を強調表示します。
ポイントが開き括弧の直前にあるときには、対応する閉じ括弧を強調表示します。
(ポイントの直後に開き括弧があるときには、
カーソルが開き括弧に重ねて表示されるので、
開き括弧を強調表示する必要はない。)
このモードをオン/オフするには、
コマンド@kbd{M-x show-paren-mode}を使います。

@node Comments, Balanced Editing, Matching, Programs
@c @section Manipulating Comments
@section コメントの操作
@c @cindex comments
@cindex コメント

@c   Because comments are such an important part of programming, Emacs
@c provides special commands for editing and inserting comments.
コメントはプログラミングの重要な部分なので、
Emacsにはコメントの編集や挿入を行うための特別なコマンドがあります。

@menu
* Comment Commands::
* Multi-Line Comments::
* Options for Comments::
@end menu

@node Comment Commands, Multi-Line Comments, , Comments
@c @subsection Comment Commands
@subsection コメント用コマンド

@kindex M-;
@c @cindex indentation for comments
@cindex コメントの字下げ
@findex indent-for-comment

@c   The comment commands insert, kill and align comments.
コメント用コマンドはコメントの挿入、削除、および位置揃えを行います。

@c WideCommands
@table @kbd
@item M-;
@c Insert or align comment (@code{indent-for-comment}).
コメントの挿入/位置揃えを行う(@code{indent-for-comment})。
@item C-x ;
@c Set comment column (@code{set-comment-column}).
コメントの桁位置を設定する(@code{set-comment-column})。
@item C-u - C-x ;
@c Kill comment on current line (@code{kill-comment}).
現在行のコメントをキルする(@code{kill-comment})。
@item C-M-j
@c Like @key{RET} followed by inserting and aligning a comment
@c (@code{indent-new-comment-line}).
@key{RET}に続けて、コメントの挿入/位置揃えを行う
(@code{indent-new-comment-line})。
@item M-x comment-region
@c Add or remove comment delimiters on all the lines in the region.
リージョン内の各行に対して、コメント区切りを追加/削除する。
@end table

@c   The command that creates a comment is @kbd{M-;} (@code{indent-for-comment}).
@c If there is no comment already on the line, a new comment is created,
@c aligned at a specific column called the @dfn{comment column}.  The comment
@c is created by inserting the string Emacs thinks comments should start with
@c (the value of @code{comment-start}; see below).  Point is left after that
@c string.  If the text of the line extends past the comment column, then the
@c indentation is done to a suitable boundary (usually, at least one space is
@c inserted).  If the major mode has specified a string to terminate comments,
@c that is inserted after point, to keep the syntax valid.
コメントを挿入するコマンドは@kbd{M-;}(@code{indent-for-comment})です。
行にコメントがなければ、新規にコメントを作成して、
@dfn{コメント桁位置}と呼ばれる特定の桁に置きます。
コメントを作成する際には、Emacsが正しいと信じるコメント開始文字列
(@code{comment-start}の値。下記参照)を挿入します。
ポイントはその文字列の直後に置かれます。
コードのテキストがコメント桁位置を越えているときには、
適当な境界に字下げします(通常は少なくとも空白1文字)。
メジャーモードでコメント終了文字列が指定されていれば、
構文を正しく保つために、ポイントの直後にその文字列を挿入します。

@c   @kbd{M-;} can also be used to align an existing comment.  If a line
@c already contains the string that starts comments, then @kbd{M-;} just moves
@c point after it and reindents it to the conventional place.  Exception:
@c comments starting in column 0 are not moved.
@kbd{M-;}は、既存のコメントを位置揃えするためにも使えます。
行にコメント開始文字列がすでに含まれていれば、
その文字列の直後にポイントを移動してから、適切な位置に字下げします。
例外として、0桁目から始まるコメントは動かしません。

@c   Some major modes have special rules for indenting certain kinds of
@c comments in certain contexts.  For example, in Lisp code, comments which
@c start with two semicolons are indented as if they were lines of code,
@c instead of at the comment column.  Comments which start with three
@c semicolons are supposed to start at the left margin.  Emacs understands
@c these conventions by indenting a double-semicolon comment using @key{TAB},
@c and by not changing the indentation of a triple-semicolon comment at all.
特定の文脈における、ある種のコメントの字下げには特殊な規則を持つ
メジャーモードもあります。
たとえば、Lispのコードでは、セミコロン2つで始まるコメントは、
コメント桁位置に揃えるのでなく、コードであるかのように字下げされます。
また、セミコロン3つで始まるコメントは左端に置くと仮定されます。
Emacsはこれらの慣習を理解していて、
セミコロン2つのコメントは@key{TAB}で字下げし、
セミコロン3つのコメントは字下げをまったく変更しません。

@example
;; 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.
@end example

@c   In C code, a comment preceded on its line by nothing but whitespace
@c is indented like a line of code.
Cのコードでは、コメントのまえに白文字しかない場合には、
そのコメントをコードのように字下げします。

@c   Even when an existing comment is properly aligned, @kbd{M-;} is still
@c useful for moving directly to the start of the comment.
既存のコメントの位置が適切に揃えられている場合でも、
コメント開始直後の位置にすぐに移動するには@kbd{M-;}が便利です。

@kindex C-u - C-x ;
@findex kill-comment
@c   @kbd{C-u - C-x ;} (@code{kill-comment}) kills the comment on the current line,
@c if there is one.  The indentation before the start of the comment is killed
@c as well.  If there does not appear to be a comment in the line, nothing is
@c done.  To reinsert the comment on another line, move to the end of that
@c line, do @kbd{C-y}, and then do @kbd{M-;} to realign it.  Note that
@c @kbd{C-u - C-x ;} is not a distinct key; it is @kbd{C-x ;} (@code{set-comment-column})
@c with a negative argument.  That command is programmed so that when it
@c receives a negative argument it calls @code{kill-comment}.  However,
@c @code{kill-comment} is a valid command which you could bind directly to a
@c key if you wanted to.
@kbd{C-u - C-x ;}(@code{kill-comment})は、
現在行にコメントがあれば、それをキルします。
コメント開始文字列のまえにある字下げもキルします。
コメントと思われるものが何もなければ、何もしません。
他の行にコメントを再挿入するには、
その行の末尾に移動してから@kbd{C-y}と打って、
さらに、位置を再調整するために@kbd{M-;}と打ちます。
@kbd{C-u - C-x ;}はひとまとまりのキーではなく、
負の引数を指定した@kbd{C-x ;}(@code{set-comment-column})で
あることに注意しましょう。
このコマンドは、負の引数を受け取ると、
@code{kill-comment}を呼ぶようにプログラムされています。
@code{kill-comment}は、望むならばキーに直接バインドできる通常のコマンドです。

@node Multi-Line Comments, Options for Comments, Comment Commands, Comments
@c @subsection Multiple Lines of Comments
@subsection 複数行にわたるコメント

@kindex C-M-j
@c @cindex blank lines in programs
@cindex プログラム中の空行
@findex indent-new-comment-line
@c   If you are typing a comment and wish to continue it on another line,
@c you can use the command @kbd{C-M-j} (@code{indent-new-comment-line}).
@c This terminates the comment you are typing, creates a new blank line
@c afterward, and begins a new comment indented under the old one.  When
@c Auto Fill mode is on, going past the fill column while typing a comment
@c causes the comment to be continued in just this fashion.  If point is
@c not at the end of the line when @kbd{C-M-j} is typed, the text on
@c the rest of the line becomes part of the new comment line.
コメントを入力していて別の行に継続したければ、
コマンド @kbd{C-M-j}(@code{indent-new-comment-line})を利用できます。
このコマンドは、入力中のコメントを終了して、
そのつぎに空行を作り、
直前のコメントの直下にくるように字下げして新たなコメントを始めます。
自動詰め込み(auto-fill)モードがオンならば、
コメントを入力中に詰め込み桁を越えると、
同様にコメントはつぎの行に継続されます。
@kbd{C-M-j}を打ったときにポイントが行末になければ、
ポイント位置から行末までのテキストは新たなコメントの一部になります。

@findex comment-region
@c   To turn existing lines into comment lines, use the @kbd{M-x
@c comment-region} command.  It adds comment delimiters to the lines that start
@c in the region, thus commenting them out.  With a negative argument, it
@c does the opposite---it deletes comment delimiters from the lines in the
@c region.
既存の行をコメントにするには、
コマンド@kbd{M-x comment-region}を使います。
このコマンドは、リージョン内で始まる各行にコメント区切り文字列を加えて
コメントにします。
負の引数を指定すると逆の操作、
つまり、コメント区切り文字列を削除します。

@c   With a positive argument, @code{comment-region} duplicates the last
@c character of the comment start sequence it adds; the argument specifies
@c how many copies of the character to insert.  Thus, in Lisp mode,
@c @kbd{C-u 2 M-x comment-region} adds @samp{;;} to each line.  Duplicating
@c the comment delimiter is a way of calling attention to the comment.  It
@c can also affect how the comment is indented.  In Lisp, for proper
@c indentation, you should use an argument of two, if between defuns, and
@c three, if within a defun.
正の引数を指定すると、@code{comment-region}は、
追加するコメント開始文字列の最後の文字を重複させます。
つまり、引数は、その文字を何回重複させるかを示します。
たとえば、Lispモードで@kbd{C-u 2 M-x commment-region}とすると、
各行に@samp{;;}を付加します。
コメント区切り文字を重複させるのは、コメントに注意を引き付けるためです。
また、コメントの字下げにも影響します。
Lispでは、適切な字下げになるように、
関数定義(defun)のあいだでは引数として3を、
関数定義の内側では引数として2を指定すべきです。

@vindex comment-padding
@c   The variable @code{comment-padding} specifies how many spaces
@c @code{comment-region} should insert on each line between the
@c comment delimiter and the line's original text.  The default is 1.
変数@code{comment-padding}は、
@code{comment-region}がコメント区切りと各行のもとのテキストとのあいだに
挿入する空白の個数を指定します。
デフォルトは1です。

@node Options for Comments,  , Multi-Line Comments, Comments
@c @subsection Options Controlling Comments
@subsection コメントを制御するオプション

@vindex comment-column
@kindex C-x ;
@findex set-comment-column
@c   The comment column is stored in the variable @code{comment-column}.  You
@c can set it to a number explicitly.  Alternatively, the command @kbd{C-x ;}
@c (@code{set-comment-column}) sets the comment column to the column point is
@c at.  @kbd{C-u C-x ;} sets the comment column to match the last comment
@c before point in the buffer, and then does a @kbd{M-;} to align the
@c current line's comment under the previous one.  Note that @kbd{C-u - C-x ;}
@c runs the function @code{kill-comment} as described above.
コメント桁位置は、変数@code{comment-column}に入っています。
この変数には明示的に値を設定できます。
あるいは、コマンド @kbd{C-x ;}(@code{set-comment-column})を使って、
ポイント位置の桁をコメント桁位置として設定できます。
@kbd{C-u C-x ;}は、バッファ内で現在行よりまえにある最後のコメントの桁位置を
コメント桁位置としてから、
@kbd{M-;}を行って現在行のコメントをまえのコメントの直下にくるように
位置を揃えます。
@kbd{C-u - C-x ;}は、前述のように
関数@code{kill-comment}を実行することに注意してください。

@c   The variable @code{comment-column} is per-buffer: setting the variable
@c in the normal fashion affects only the current buffer, but there is a
@c default value which you can change with @code{setq-default}.
@c @xref{Locals}.  Many major modes initialize this variable for the
@c current buffer.
変数@code{comment-column}は、バッファごとの変数です。
つまり、通常の方法で設定すると、カレントバッファだけに影響しますが、
@code{setq-default}でデフォルト値を変更できます。
@xref{Locals}。
多くのメジャーモードでは、この変数をカレントバッファ用に初期化します。

@vindex comment-start-skip
@c   The comment commands recognize comments based on the regular
@c expression that is the value of the variable @code{comment-start-skip}.
@c Make sure this regexp does not match the null string.  It may match more
@c than the comment starting delimiter in the strictest sense of the word;
@c for example, in C mode the value of the variable is @code{@t{"/\\*+
@c *"}}, which matches extra stars and spaces after the @samp{/*} itself.
@c (Note that @samp{\\} is needed in Lisp syntax to include a @samp{\} in
@c the string, which is needed to deny the first star its special meaning
@c in regexp syntax.  @xref{Regexps}.)
コメント用コマンドは、変数@code{comment-start-skip}の正規表現に基づいて
コメントを認識します。
この正規表現が空文字列には一致しないようにしてください。
厳密にはコメント開始文字列よりも長く一致するかもしれません。
たとえば、Cモードではこの変数の値は@code{@t{"/\\*+ *"}}ですが、
これは @samp{/*}のうしろの余分なアスタリスクと空白に一致します。
(Lispの構文では、文字列中に@samp{\}を含めるために@samp{\\}とする必要がある。
この@samp{\}は、最初のアスタリスクの正規表現における特別な
意味を抑制するために必要。
@pxref{Regexps}。)

@vindex comment-start
@vindex comment-end
@c   When a comment command makes a new comment, it inserts the value of
@c @code{comment-start} to begin it.  The value of @code{comment-end} is
@c inserted after point, so that it will follow the text that you will insert
@c into the comment.  In C mode, @code{comment-start} has the value
@c @w{@code{"/* "}} and @code{comment-end} has the value @w{@code{" */"}}.
コメント用コマンドで新たなコメントを作ると、
コメントを始めるために@code{comment-start}の値を挿入します。
また、ポイントの直後には@code{comment-end}の値が挿入されて、
これから入力するテキストのあとに続くことになります。
Cモードでは、@code{comment-start}の値は@w{@code{"/* "}}、
@code{comment-end}の値は@w{@code{" */"}}です。

@vindex comment-multi-line
@c   The variable @code{comment-multi-line} controls how @kbd{C-M-j}
@c (@code{indent-new-comment-line}) behaves when used inside a comment.  If
@c @code{comment-multi-line} is @code{nil}, as it normally is, then the
@c comment on the starting line is terminated and a new comment is started
@c on the new following line.  If @code{comment-multi-line} is not
@c @code{nil}, then the new following line is set up as part of the same
@c comment that was found on the starting line.  This is done by not
@c inserting a terminator on the old line, and not inserting a starter on
@c the new line.  In languages where multi-line comments work, the choice
@c of value for this variable is a matter of taste.
変数@code{comment-multi-line}は、
@kbd{C-M-j}(@code{indent-new-comment-line})が
コメントの内側で使われたときの動作を制御します。
@code{comment-multi-line}が@code{nil}(通常の設定)ならば、
現在行のコメントを終了し、新たなコメントをつぎの行から始めます。
@code{comment-multi-line}が@code{nil}以外ならば、
現在行と同じコメントが継続されます。
つまり、現在行のコメントを終えず、新たな行にも開始文字列を挿入しません。
複数行にわたるコメントを許す言語では、
この変数に設定する値は好みの問題です。

@vindex comment-indent-function
@c   The variable @code{comment-indent-function} should contain a function
@c that will be called to compute the indentation for a newly inserted
@c comment or for aligning an existing comment.  It is set differently by
@c various major modes.  The function is called with no arguments, but with
@c point at the beginning of the comment, or at the end of a line if a new
@c comment is to be inserted.  It should return the column in which the
@c comment ought to start.  For example, in Lisp mode, the indent hook
@c function bases its decision on how many semicolons begin an existing
@c comment, and on the code in the preceding lines.
変数@code{comment-indent-function}には、
新たに挿入したコメントの字下げや
既存のコメントに桁を揃えるための字下げを計算する関数を
設定する必要があります。
この変数には、メジャーモードごとに異なった関数が設定されます。
この関数は引数なしで呼ばれますが、
コメントがあるときにはその開始位置にポイントを置いて、
新規コメントの挿入時には行末にポイントを置いて呼ばれます。
戻り値は、コメントを始めるべき桁位置です。
たとえば、Lispモードでは、この字下げ用フック関数は、
既存のコメントのセミコロンの個数と
まえの行のコードに基づいて計算を行います。

@node Balanced Editing, Symbol Completion, Comments, Programs
@c @section Editing Without Unbalanced Parentheses
@section 括弧の対応を保った編集

@table @kbd
@item M-(
@c Put parentheses around next sexp(s) (@code{insert-parentheses}).
つぎの(1つ以上の)S式を括弧で囲む(@code{insert-parentheses})。
@item M-)
@c Move past next close parenthesis and reindent
@c (@code{move-past-close-and-reindent}).
つぎの閉じ括弧のうしろへ移動してから字下げし直す
(@code{move-past-close-and-reindent})。
@end table

@kindex M-(
@kindex M-)
@findex insert-parentheses
@findex move-past-close-and-reindent
@c   The commands @kbd{M-(} (@code{insert-parentheses}) and @kbd{M-)}
@c (@code{move-past-close-and-reindent}) are designed to facilitate a style
@c of editing which keeps parentheses balanced at all times.  @kbd{M-(}
@c inserts a pair of parentheses, either together as in @samp{()}, or, if
@c given an argument, around the next several sexps.  It leaves point after
@c the open parenthesis.  The command @kbd{M-)} moves past the close
@c parenthesis, deleting any indentation preceding it, and indenting with
@c @kbd{C-j} after it.
コマンド@kbd{M-(}(@code{insert-parenthesis})と
@kbd{M-)}(@code{move-past-close-and-reindent})は、
括弧の対応をつねに保ったまま編集するために設計されました。
@kbd{M-(}は一対の括弧を挿入します。
引数がなければ@samp{()}を挿入しますが、
引数を指定すると、つぎのその個数分のS式を括弧で囲みます。
ポイントは開き括弧の直後に置かれます。
コマンド@kbd{M-)}は、閉じ括弧のまえにある字下げを削除しながら
閉じ括弧のうしろにポイントを移動し、
そのあと、@kbd{C-j}で字下げします。

@c   For example, instead of typing @kbd{( F O O )}, you can type @kbd{M-(
@c F O O}, which has the same effect except for leaving the cursor before
@c the close parenthesis.
たとえば、@kbd{( F O O )}と打つかわりに@kbd{M-( F O O}と打てば、
カーソルが閉じ括弧のまえにくることを除けば同じ効果を得られます。

@vindex parens-require-spaces
@c   @kbd{M-(} may insert a space before the open parenthesis, depending on
@c the syntax class of the preceding character.  Set
@c @code{parens-require-spaces} to @code{nil} value if you wish to inhibit
@c this.
@kbd{M-(}は、直前の文字の構文クラスによっては、
開き括弧のまえに空白を1個挿入することがあります。
これを禁止したければ、
@code{parens-require-spaces}に@code{nil}を設定してください。

@node Symbol Completion, Which Function, Balanced Editing, Programs
@c @section Completion for Symbol Names
@section シンボル名の補完
@c @cindex completion (symbol names)
@cindex 補完(シンボル名)

@c   Usually completion happens in the minibuffer.  But one kind of completion
@c is available in all buffers: completion for symbol names.
通常、補完はミニバッファで行われます。
しかし、ある種の補完は任意のバッファで利用できます。
それはシンボル名に対する補完です。

@kindex M-TAB
@c   The character @kbd{M-@key{TAB}} runs a command to complete the partial
@c symbol before point against the set of meaningful symbol names.  Any
@c additional characters determined by the partial name are inserted at
@c point.
@kbd{M-@key{TAB}}は、ポイント直前の部分的なシンボルを、
意味のあるシンボル名の集合から補完するコマンドを実行します。
部分的な名前から補完された追加文字はポイント位置に挿入されます。

@c   If the partial name in the buffer has more than one possible completion
@c and they have no additional characters in common, a list of all possible
@c completions is displayed in another window.
バッファ内の部分的な名前に対して、
複数個の補完候補があり、しかも、追加できる共通部分がない場合には、
補完候補一覧を別のウィンドウに表示します。

@c @cindex completion using tags
@c @cindex tags completion
@c @cindex Info index completion
@cindex タグを用いた補完
@cindex タグ補完
@cindex info索引補完
@findex complete-symbol
@c   In most programming language major modes, @kbd{M-@key{TAB}} runs the
@c command @code{complete-symbol}, which provides two kinds of completion.
@c Normally it does completion based on a tags table (@pxref{Tags}); with a
@c numeric argument (regardless of the value), it does completion based on
@c the names listed in the Info file indexes for your language.  Thus, to
@c complete the name of a symbol defined in your own program, use
@c @kbd{M-@key{TAB}} with no argument; to complete the name of a standard
@c library function, use @kbd{C-u M-@key{TAB}}.  Of course, Info-based
@c completion works only if there is an Info file for the standard library
@c functions of your language, and only if it is installed at your site.
ほとんどのプログラム言語向けメジャーモードでは、
@kbd{M-@key{TAB}}はコマンド@code{complete-symbol}を実行します。
この関数には、2種類の補完機能があります。
通常、このコマンドはタグテーブル(@pxref{Tags})に基づいて補完を行います。 
数引数(値は無関係)を指定すると、当該言語のinfoファイルの索引に
並べられた名前を対象として補完を行います。
すなわち、プログラム中で定義されたシンボル名を補完するには
引数なしで@kbd{M-@key{TAB}}を使い、
標準ライブラリ関数の名前を補完するには@kbd{C-u M-@key{TAB}}を使います。
もちろん、infoに基づいた補完は、使用言語の標準ライブラリ関数に対する
infoファイルがあり、かつ、それがインストールされている場合にだけ動作します。

@c @cindex Lisp symbol completion
@c @cindex completion in Lisp
@cindex Lispシンボルの補完
@cindex Lisp中の補完
@findex lisp-complete-symbol
@c   In Emacs-Lisp mode, the name space for completion normally consists of
@c nontrivial symbols present in Emacs---those that have function
@c definitions, values or properties.  However, if there is an
@c open-parenthesis immediately before the beginning of the partial symbol,
@c only symbols with function definitions are considered as completions.
@c The command which implements this is @code{lisp-complete-symbol}.
Emacs Lispモードでは、補完対象の名前空間は、
関数定義、値や属性を持つEmacs中の特殊なシンボルから成ります。
しかし、部分的なシンボルの直前に開き括弧があれば、
関数定義を持つシンボルだけを補完対象とします。
これを実現するコマンドは@code{lisp-complete-symbol}です。

@c   In Text mode and related modes, @kbd{M-@key{TAB}} completes words
@c based on the spell-checker's dictionary.  @xref{Spelling}.
テキスト(text)モードとその関連モードでは、
@kbd{M-@key{TAB}}はスペルチェッカの辞書に基づいた補完を行います。
@xref{Spelling}。

@node Which Function, Documentation, Symbol Completion, Programs
@c @section Which Function Mode
@section 関数名表示モード(which-functionモード)

@c   Which Function mode is a minor mode that displays the current function
@c name in the mode line, as you move around in a buffer.
関数名表示(which-function)モードは、
バッファ内を動き廻るに従って現在の関数名をモード行に表示する
マイナモードです。

@findex which-function-mode
@vindex which-func-modes
@c   To enable (or disable) Which Function mode, use the command @kbd{M-x
@c which-function-mode}.  This command is global; it applies to all
@c buffers, both existing ones and those yet to be created.  However, this
@c only affects certain major modes, those listed in the value of
@c @code{which-func-modes}.  (If the value is @code{t}, then Which Function
@c mode applies to all major modes that know how to support it---which are
@c the major modes that support Imenu.)
関数名表示(which-function)モードをオン(あるいはオフ)にするには、
コマンド@kbd{M-x which-function-mode}を使います。
このコマンドはグローバルです。
つまり、既存のバッファでもこれから作るバッファでも、
すべてのバッファに通用します。
しかし、@code{which-func-modes}の値で指定された
特定のメジャーモードでのみ効果があります。
(@code{which-func-modes}のデフォルト値は@code{t}であり、
関数名表示(which-function)モードの支援方法を知っている
すべてのメジャーモードに適用されることを意味する。
具体的には、imenuを使えるメジャーモード。)

@node Documentation, Change Log, Which Function, Programs
@c @section Documentation Commands
@section 説明文書用コマンド

@c   As you edit Lisp code to be run in Emacs, the commands @kbd{C-h f}
@c (@code{describe-function}) and @kbd{C-h v} (@code{describe-variable}) can
@c be used to print documentation of functions and variables that you want to
@c call.  These commands use the minibuffer to read the name of a function or
@c variable to document, and display the documentation in a window.
Emacsで実行するLispコードを編集するときには、
関数や変数の説明文字列を表示するコマンド、
@kbd{C-h f}(@code{describe-function})や
@kbd{C-h v}(@code{describe-variable})を利用できます。
これらのコマンドは、説明文字列を表示したい関数や変数の名前を
ミニバッファから読み取り、ウィンドウに説明文字列を表示します。

@c   For extra convenience, these commands provide default arguments based on
@c the code in the neighborhood of point.  @kbd{C-h f} sets the default to the
@c function called in the innermost list containing point.  @kbd{C-h v} uses
@c the symbol name around or adjacent to point as its default.
たいへん便利なことに、これらのコマンドはポイント近傍のコードから、
デフォルトの引数を選択します。
@kbd{C-h f}は、ポイントを含むもっとも内側のリストで呼ばれる関数をデフォルト
とします。
@kbd{C-h v}は、ポイントの周辺にあるか隣接するシンボル名を
デフォルトとします。

@c @cindex Eldoc mode
@cindex eldocモード
@cindex モード、Eldoc
@findex eldoc-mode
@c   For Emacs Lisp code, you can also use Eldoc mode.  This minor mode
@c constantly displays in the echo area the argument list for the function
@c being called at point.  (In other words, it finds the function call that
@c point is contained in, and displays the argument list of that function.)
@c Eldoc mode applies in Emacs Lisp and Lisp Interaction modes only.  Use
@c the command @kbd{M-x eldoc-mode} to enable or disable this feature.
Emacs Lispコードに対しては、eldocモードも使えます。
このマイナモードは、ポイント位置で呼び出されている関数の引数リストを、
たえずエコー領域に表示します。
(いいかえれば、ポイントを含む関数呼び出しを探し、
その関数の引数リストを表示する。)
eldocマイナモードは、Emacs Lispモードと
Lisp対話(lisp-interaction)モードだけに適用できます。
この機能をオン/オフするには、コマンド@kbd{M-x eldoc-mode}を使います。

@findex info-lookup-symbol
@findex info-lookup-file
@kindex C-h C-i
@c   For C, Lisp, and other languages, you can use @kbd{C-h C-i}
@c (@code{info-lookup-symbol}) to view the Info documentation for a symbol.
@c You specify the symbol with the minibuffer; by default, it uses the
@c symbol that appears in the buffer at point.  The major mode determines
@c where to look for documentation for the symbol---which Info files and
@c which indices.  You can also use @kbd{M-x info-lookup-file} to look for
@c documentation for a file name.
C、Lisp、その他言語のシンボルのinfo文書を見るには
@kbd{C-h C-i}(@code{info-lookup-symbol})を使います。
ミニバッファでシンボルを指定します。
デフォルトは、バッファ中のポイント位置にあるシンボルです。
シンボルに対する説明文書を探す場所、つまり、
どのinfoファイルのどの索引を探せばよいかは、
メジャーモードが決定します。
また、ファイル名に対する説明文書を探すには
@kbd{M-x info-lookup-file}を使います。

@findex manual-entry
@c   You can read the ``man page'' for an operating system command, library
@c function, or system call, with the @kbd{M-x manual-entry} command.  It
@c runs the @code{man} program to format the man page, and runs it
@c asynchronously if your system permits, so that you can keep on editing
@c while the page is being formatted.  (MS-DOS and MS-Windows 3 do not
@c permit asynchronous subprocesses, so on these systems you cannot edit
@c while Emacs waits for @code{man} to exit.)  The result goes in a buffer
@c named @samp{*Man @var{topic}*}.  These buffers use a special major mode,
@c Man mode, that facilitates scrolling and examining other manual pages.
@c For details, type @kbd{C-h m} while in a man page buffer.
@kbd{M-x manual-entry}コマンドを使って、
オペレーティングシステムのコマンド、ライブラリ関数、システムコールの
『マニュアルページ』を読むことができます。
このコマンドは、マニュアルページを清書するために
@code{man}プログラムを実行します。
システムが許せば非同期に実行するので、
マニュアルページが清書されるまで、編集を継続できます
(MS-DOSやMS-Windows 3.xでは、非同期的なサブプロセスを実行できない。
このため、これらのシステムでは@code{man}の終了をEmacsが待つあいだは
編集できない)。
結果は、@samp{*Man @var{topic}*}という名前のバッファに入ります。
これらのバッファではマン(man)モードと呼ばれる特別な
メジャーモードが使われ、
スクロールや他のマニュアルページの調査を容易に行えます。
より詳しくは、マニュアルページ用のバッファで、
@kbd{C-h m}と打ってください。

@vindex Man-fontify-manpage-flag
@c   For a long man page, setting the faces properly can take substantial
@c time.  By default, Emacs uses faces in man pages if Emacs can display
@c different fonts or colors.  You can turn off use of faces in man pages
@c by setting the variable @code{Man-fontify-manpage-flag} to @code{nil}.
長いマニュアルページでは、適切なフェイスを設定するにはとても時間がかかります。
さまざまなフォントや表示色を表示できる環境であれば、
デフォルトでマニュアルページにフェイスを用いるようになっています。
変数@code{Man-fontify-manpage-flag}に@code{nil}を設定すれば、
マニュアルページにおけるフェイスの使用をオフにできます。

@findex Man-fontify-manpage
@c   If you insert the text of a man page into an Emacs buffer in some
@c other fashion, you can use the command @kbd{M-x Man-fontify-manpage} to
@c perform the same conversions that @kbd{M-x manual-entry} does.
他の方法でマニュアルページのテキストをEmacsバッファに挿入した場合、
@kbd{M-x manual-entry}と同じ変換を施すには、
そこで@kbd{M-x Man-fontify-manpage}コマンドを実行します。

@c   Eventually the GNU project hopes to replace most man pages with
@c better-organized manuals that you can browse with Info.  @xref{Misc
@c Help}.  Since this process is only partially completed, it is still
@c useful to read manual pages.
GNUプロジェクトでは最終的に、ほとんどのマニュアルページを
infoで閲覧可能なよりよく構成されたマニュアルに置き換えることを望んでいます。
@xref{Misc Help}。
この作業は、ほんの一部が完了しただけなので、
まだマニュアルページを読めることは有益です。

@node Change Log, Tags, Documentation, Programs
@c @section Change Logs
@section 変更記録

@c @cindex change log
@cindex 変更記録
@cindex チェンジログ
@kindex C-x 4 a
@findex add-change-log-entry-other-window
@c   The Emacs command @kbd{C-x 4 a} adds a new entry to the change log
@c file for the file you are editing
@c (@code{add-change-log-entry-other-window}).
コマンド@kbd{C-x 4 a}は、編集中のファイルに対する
新たな項目を変更記録ファイルに追加します
(@code{add-change-log-entry-other-window})。

@c   A change log file contains a chronological record of when and why you
@c have changed a program, consisting of a sequence of entries describing
@c individual changes.  Normally it is kept in a file called
@c @file{ChangeLog} in the same directory as the file you are editing, or
@c one of its parent directories.  A single @file{ChangeLog} file can
@c record changes for all the files in its directory and all its
@c subdirectories.
変更記録ファイルは、プログラムを変更した日付やその理由を
時間順に記録したもので、個々の変更を記述した項目の並びから成ります。
通常は、編集しているファイルと同じディレクトリ、あるいは、
その親ディレクトリに置いた@file{ChangeLog}と呼ばれる
ファイルに保存されています。
1つの@file{ChangeLog}ファイルで、このファイルを置いたディレクトリや
そのサブディレクトリに置いた全ファイルの変更を記録できます。

@c   A change log entry starts with a header line that contains your name,
@c your email address (taken from the variable @code{user-mail-address}),
@c and the current date and time.  Aside from these header lines, every
@c line in the change log starts with a space or a tab.  The bulk of the
@c entry consists of @dfn{items}, each of which starts with a line starting
@c with whitespace and a star.  Here are two entries, both dated in May
@c 1993, each with two items:
変更記録項目は、名前、(@code{user-mail-address}から得られた)
電子メイルアドレス、現在の日付と時刻から成るヘッダ行で始まります。
変更記録内の各行はヘッダ行を除いて、つねに空白かタブで始まります。
1つの項目は@dfn{小項目}から構成され、
各小項目は空白と星印で始まる行で始まります。
以下は、1993年5月付けの2つの項目で、
それぞれに2つの小項目があります。

@iftex
@medbreak
@end iftex
@smallexample
1993-05-25  Richard Stallman  <rms@@gnu.org>

        * man.el: Rename symbols `man-*' to `Man-*'.
        (manual-entry): Make prompt string clearer.

        * simple.el (blink-matching-paren-distance):
        Change default to 12,000.

1993-05-24  Richard Stallman  <rms@@gnu.org>

        * vc.el (minor-mode-map-alist): Don't use it if it's void.
        (vc-cancel-version): Doc fix.
@end smallexample

@noindent
@c (Previous Emacs versions used a different format for the date.)
(Emacsの以前の版では、日付の形式が異なる。)

@c   One entry can describe several changes; each change should have its
@c own item.  Normally there should be a blank line between items.  When
@c items are related (parts of the same change, in different places), group
@c them by leaving no blank line between them.  The second entry above
@c contains two items grouped in this way.
1つの項目で複数の変更を記述できます。
各変更について、それぞれの小項目を用意しなくてはいけません。
通常、小項目のあいだには空行がなくてはいけません。
小項目が関連している(場所は異なるが同じ変更の一部分の)場合には、
それらのあいだには空行を入れずに一塊にしておきます。
上記の2番目の項目には、このようにしてまとめた2つの小項目が含まれています。

@c   @kbd{C-x 4 a} visits the change log file and creates a new entry
@c unless the most recent entry is for today's date and your name.  It also
@c creates a new item for the current file.  For many languages, it can
@c even guess the name of the function or other object that was changed.
@kbd{C-x 4 a}は、変更記録ファイルを訪問して、
最新の項目が今日の日付で当人の名前のものでなければ、
新たに項目を作成します。
また、現在のファイルに対する新たな小項目も作成します。
多くの言語に対して、変更された関数名やその他のオブジェクトを
推測することもできます。

@c @cindex Change Log mode
@cindex 変更記録モード(Change Log mode)
@cindex change-logモード
@cindex モード、Change Log
@findex change-log-mode
@c   The change log file is visited in Change Log mode.  In this major
@c mode, each bunch of grouped items counts as one paragraph, and each
@c entry is considered a page.  This facilitates editing the entries.
@c @kbd{C-j} and auto-fill indent each new line like the previous line;
@c this is convenient for entering the contents of an entry.
変更記録ファイルは、変更記録(change-log)モードで訪問します。
このメジャーモードでは、(空行で区切らない)ひとまとまりの小項目群を
段落として扱い、各項目をページとして扱います。
これにより項目の編集が容易になります。
@kbd{C-j}や自動詰め込みにより、
新たな行は直前の行と同様に字下げされます。
これは項目内容を入力するのに便利です。

@c   Version control systems are another way to keep track of changes in your
@c program and keep a change log.  @xref{Log Buffer}.
プログラムの変更を掌握し、変更記録を維持する他の手段としては、
版管理(バージョンコントロール)システムがあります。
@xref{Log Buffer}。

@node Tags, Emerge, Change Log, Programs
@c @section Tags Tables
@section タグテーブル
@c @cindex tags table
@cindex タグテーブル

@c   A @dfn{tags table} is a description of how a multi-file program is
@c broken up into files.  It lists the names of the component files and the
@c names and positions of the functions (or other named subunits) in each
@c file.  Grouping the related files makes it possible to search or replace
@c through all the files with one command.  Recording the function names
@c and positions makes possible the @kbd{M-.} command which finds the
@c definition of a function by looking up which of the files it is in.
@dfn{タグテーブル}とは、複数のファイルで構成されるプログラムが、
どのように各ファイルに分割されているのか記述したものです。
これは、プログラムを構成するファイル名、
そのファイルに入っている関数の名前(または、名前の付いた別の単位)や
ファイル内の位置の一覧です。
こうして関連するファイルをまとめておけば、
全ファイルを対象とした探索や置換をコマンド1つで行えます。
また、関数名とその位置を記録してあるので、
関数がどのファイルに入っているか調べて関数定義をみつけだす
@kbd{M-.}のようなコマンドを実現できます。

@c   Tags tables are stored in files called @dfn{tags table files}.  The
@c conventional name for a tags table file is @file{TAGS}.
タグテーブルは、@dfn{タグテーブルファイル}と呼ばれるファイルに格納されます。
このファイルの慣習的な名前は@file{TAGS}です。

@c   Each entry in the tags table records the name of one tag, the name of the
@c file that the tag is defined in (implicitly), and the position in that file
@c of the tag's definition.
タグテーブルの各項目は、タグ名、タグが(暗黙に)定義されているファイルの名前、
そして、ファイル中でタグが定義されている位置を記録しています。

@c   Just what names from the described files are recorded in the tags table
@c depends on the programming language of the described file.  They
@c normally include all functions and subroutines, and may also include
@c global variables, data types, and anything else convenient.  Each name
@c recorded is called a @dfn{tag}.
もとのプログラムファイルから、どんな名前がタグテーブルに記録されるかは、
プログラム言語によって異なります。
一般的には、すべての関数やサブルーチンを含み、
大域変数、データ型、あると便利なその他の情報などを含むこともあります。
記録された個々の名前を@dfn{タグ}と呼びます。

@menu
* Tag Syntax::		Tag syntax for various types of code and text files.  
* Create Tags Table::	Creating a tags table with @code{etags}.
* 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.
@end menu

@node Tag Syntax, Create Tags Table, , Tags
@c @subsection Source File Tag Syntax
@subsection ソースファイルのタグ構文

@c   Here is how tag syntax is defined for the most popular languages:
ここでは、広く一般に使われている言語に対するタグ構文の定義を紹介します。

@itemize @bullet
@item
@c In C code, any C function or typedef is a tag, and so are definitions of
@c @code{struct}, @code{union} and @code{enum}.  @code{#define} macro
@c definitions and @code{enum} constants are also tags, unless you specify
@c @samp{--no-defines} when making the tags table.  Similarly, global
@c variables are tags, unless you specify @samp{--no-globals}.  Use of
@c @samp{--no-globals} and @samp{--no-defines} can make the tags table file
@c much smaller.
Cのコードでは、関数やtypedefで定義される型はタグであり、
@code{struct}、@code{union}、@code{enum}の定義もやはりタグである。
また、タグテーブルを作成するときにオプション@samp{--no-defines}を
指定しなければ、@code{#define}によるマクロ定義や
@code{enum}の定数もタグとして扱う。
同様に、大域変数も@samp{--no-globals}を指定しない限りタグになる。
@samp{--no-globals}と@samp{--no-defines}を指定すると、
タグテーブルファイルはかなり小さくなる。

@item
@c In C++ code, in addition to all the tag constructs of C code, member
@c functions are also recognized, and optionally member variables if you
@c use the @samp{--members} option.  Tags for variables and functions in
@c classes are named @samp{@var{class}::@var{variable}} and
@c @samp{@var{class}::@var{function}}.
C++のコードでは、Cのコードのタグ構成要素に加えて、
メンバ関数もタグとして認識される。
@samp{--members}オプションを指定すれば、メンバ変数もタグになる。
クラス内の変数と関数に対するタグには、それぞれ、
@samp{@var{class}::@var{variable}}、@samp{@var{class}::@var{function}}と
名前が付く。

@item
@c In Java code, tags include all the constructs recognized in C++, plus
@c the @code{extends} and @code{implements} constructs.  Tags for variables
@c and functions in classes are named @samp{@var{class}.@var{variable}} and
@c @samp{@var{class}.@var{function}}.
Javaのコードでは、C++のタグ構成要素に加えて、
@code{extends}と@code{implements}に現れる名前もタグとして含む。
クラス内の変数と関数に対するタグには、それぞれ、
@samp{@var{class}.@var{variable}}、
@samp{@var{class}.@var{function}}と名前が付く。

@item
@c In La@TeX{} text, the argument of any of the commands @code{\chapter},
@c @code{\section}, @code{\subsection}, @code{\subsubsection},
@c @code{\eqno}, @code{\label}, @code{\ref}, @code{\cite}, @code{\bibitem},
@c @code{\part}, @code{\appendix}, @code{\entry}, or @code{\index}, is a
@c tag.@refill
La@TeX{}のテキストでは、@code{\chapter}、@code{\section}、@code{\subsection}、
@code{\subsubsection}、@code{\eqno}、@code{\label}、@code{\ref}、
@code{\cite}、@code{\bibitem}、@code{\part}、@code{\appendix}、
@code{\entry}、@code{\index}のコマンドの引数がタグになる。

@c Other commands can make tags as well, if you specify them in the
@c environment variable @code{TEXTAGS} before invoking @code{etags}.  The
@c value of this environment variable should be a colon-separated list of
@c command names.  For example,
その他のLa@TeX{}コマンドでも、@code{etags}を起動するまえに、
環境変数@code{TEXTAGS}にそれらのコマンドを指定しておけばタグの対象になる。
この環境変数の値は、コマンド名をコロンで区切った並び。
たとえば、(bourneシェルでは)

@example
TEXTAGS="def:newcommand:newenvironment"
export TEXTAGS
@end example

@noindent
@c specifies (using Bourne shell syntax) that the commands @samp{\def},
@c @samp{\newcommand} and @samp{\newenvironment} also define tags.
とすると、@samp{\def}、@samp{\newcommand}、@samp{\newenvironment}の
コマンドの引数もタグの対象になる。

@item
@c In Lisp code, any function defined with @code{defun}, any variable
@c defined with @code{defvar} or @code{defconst}, and in general the first
@c argument of any expression that starts with @samp{(def} in column zero, is
@c a tag.
Lispコードでは、@code{defun}で定義した関数、
@code{defvar}や@code{defconst}で定義した変数、
および、一般に0桁目から@samp{(def}で始まる任意の式の最初の引数がタグ。

@item
@c In Scheme code, tags include anything defined with @code{def} or with a
@c construct whose name starts with @samp{def}.  They also include variables
@c set with @code{set!} at top level in the file.
Schemeコードでは、
@code{def}で定義されるものと、名前が@samp{def}で始まるものがタグに含まれる。
また、ファイル内のトップレベルで@code{set!}を
使って値が設定される変数もタグ。
@end itemize

@c   Several other languages are also supported:
他にも以下の言語で使えます。

@itemize @bullet
@item
@c In assembler code, labels appearing at the beginning of a line,
@c followed by a colon, are tags.
アセンブリコードでは、行の先頭から始まりコロンが続くラベルはタグ。

@item
@c In Bison or Yacc input files, each rule defines as a tag the nonterminal
@c it constructs.  The portions of the file that contain C code are parsed
@c as C code.
BisonやYaccの入力ファイルでは、
各構文規則で定義する非終端記号をタグとする。
ファイル内のCコードの部分に対しては、Cのコードとしてタグの解析を行う。

@item
@c In Cobol code, tags are paragraph names; that is, any word starting in
@c column 8 and followed by a period.
Cobolでは、段落名、すなわち、8桁目から始まりピリオドが続く任意の単語がタグ。

@item
@c In Erlang code, the tags are the functions, records, and macros defined
@c in the file.
Erlangコードでは、ファイル内で定義された関数、レコード、マクロがタグ。

@item
@c In Fortran code, functions, subroutines and blockdata are tags.
Fortranコードでは、関数、サブルーチン、ブロックデータがタグ。

@item
@c In Objective C code, tags include Objective C definitions for classes,
@c class categories, methods, and protocols.
Objective-Cコードでは、クラス、クラスカテゴリ、メソッド、
プロトコルの定義がタグ。

@item
@c In Pascal code, the tags are the functions and procedures defined in
@c the file.
Pascalコードでは、関数と手続きがタグ。

@item
@c In Perl code, the tags are the procedures defined by the @code{sub}
@c keyword.
Perlコードでは、キーワード@code{sub}で定義される手続きがタグ。

@item
@c In Postscript code, the tags are the functions.
Postscriptコードでは、関数(演算子)がタグ。

@item
@c In Prolog code, a tag name appears at the left margin.
Prologコードでは、左端に現れる名前がタグ。
@end itemize

@c   You can also generate tags based on regexp matching (@pxref{Create
@c Tags Table}) to handle other formats and languages.
正規表現に基づいてタグを生成する方法
(@pxref{Create Tags Table})もあるので、
上記以外の形式や言語を扱うこともできます。

@node Create Tags Table, Select Tags Table, Tag Syntax, Tags
@c @subsection Creating Tags Tables
@subsection タグテーブルの作成
@c @cindex @code{etags} program
@cindex @code{etags}プログラム

@c   The @code{etags} program is used to create a tags table file.  It knows
@c the syntax of several languages, as described in
タグテーブルファイルを作成するには、@code{etags}プログラムを使います。
@code{etags}は、数種類の言語について、
構文を解析しタグを取り出すことができます。
@iftex
@c the previous section.
これは前節で述べたとおりです。
@end iftex
@ifinfo
@c @ref{Tag Syntax}.
@ref{Tag Syntax}。
@end ifinfo
@c Here is how to run @code{etags}:
つぎのように実行します。

@example
etags @var{inputfiles}@dots{}
@end example

@noindent
@c The @code{etags} program reads the specified files, and writes a tags table
@c named @file{TAGS} in the current working directory.  @code{etags}
@c recognizes the language used in an input file based on its file name and
@c contents.  You can specify the language with the
@c @samp{--language=@var{name}} option, described below.
@code{etags}は指定されたファイルを読み、
カレント作業ディレクトリの@file{TAGS}という名前のファイルに
タグテーブルを書き出します。
@code{etags}は、ファイル名とその内容から自動的に使用言語を識別します。
後述の@samp{--language=@var{name}}オプションで、
言語を明示することもできます。

@c   If the tags table data become outdated due to changes in the files
@c described in the table, the way to update the tags table is the same way it
@c was made in the first place.  It is not necessary to do this often.
ファイルを変更するなどしてタグテーブルの内容が古くなった場合、
テーブルを更新するには、最初にタグテーブルを作成した手順を
繰り返します。
頻繁に更新する必要はありません。

@c   If the tags table fails to record a tag, or records it for the wrong
@c file, then Emacs cannot possibly find its definition.  However, if the
@c position recorded in the tags table becomes a little bit wrong (due to
@c some editing in the file that the tag definition is in), the only
@c consequence is a slight delay in finding the tag.  Even if the stored
@c position is very wrong, Emacs will still find the tag, but it must
@c search the entire file for it.
タグテーブルに記録できなかったり、誤ったファイルを記録してしまった場合、
Emacsはタグの定義をみつけることはできません。
しかし、(タグの定義を含んだファイルを多少編集するなどしたために)
タグテーブルに記録された位置が多少ズレている程度ならば、
タグをみつけるのに通常より少し時間がかかるだけです。
記録された位置が大幅に狂っていたとしても、
Emacsはタグをみつけることができますが、
そのためにファイル全体を調べなくてはなりません。

@c   So you should update a tags table when you define new tags that you want
@c to have listed, or when you move tag definitions from one file to another,
@c or when changes become substantial.  Normally there is no need to update
@c the tags table after each edit, or even every day.
ですから、新しいタグを定義したとき、タグの定義を別のファイルに移動したとき、
ファイルを相当変更したときには、タグテーブルの更新が必要です。
しかし、ファイルを編集するつどタグテーブルを更新する必要はありませんし、
毎日更新する必要すらないでしょう。

@c   One tags table can effectively include another.  Specify the included
@c tags file name with the @samp{--include=@var{file}} option when creating
@c the file that is to include it.  The latter file then acts as if it
@c contained all the files specified in the included file, as well as the
@c files it directly contains.
タグテーブルに別のタグテーブルを取り込むこともできます。
取り込むタグファイル名をオプション@samp{--include=@var{file}}で
指定してタグファイルを作成します。
このように作成したタグファイルには、
指定したソースファイルに加えて、
取り込んだタグファイルに記録されていたファイルも含まれます。

@c   If you specify the source files with relative file names when you run
@c @code{etags}, the tags file will contain file names relative to the
@c directory where the tags file was initially written.  This way, you can
@c move an entire directory tree containing both the tags file and the
@c source files, and the tags file will still refer correctly to the source
@c files.
@code{etags}を実行するときに相対ファイル名でソースファイルを指定すると、
タグファイルには、タグファイルを書き出したときのディレクトリを
基準にしたファイル名が記録されます。
こうした場合、
タグファイルとソースファイルを含んだディレクトリ木構造全体を
移動することができ、しかも、タグファイルはソースファイルを正しく指し続けます。

@c   If you specify absolute file names as arguments to @code{etags}, then
@c the tags file will contain absolute file names.  This way, the tags file
@c will still refer to the same files even if you move it, as long as the
@c source files remain in the same place.  Absolute file names start with
@c @samp{/}, or with @samp{@var{device}:/} on MS-DOS and MS-Windows.
@code{etags}の引数として絶対ファイル名を指定すると、
タグファイルには絶対ファイル名が記録されます。
こうした場合、ソースファイルが同じ場所にある限り、
タグファイルを移動してもタグファイルは同じファイルを指し続けます。
絶対ファイル名は、@samp{/}、あるいは、
MS-DOSとMS-Windowsでは@samp{@var{device}:/}で始まります。

@c   When you want to make a tags table from a great number of files, you
@c may have problems listing them on the command line, because some systems
@c have a limit on its length.  The simplest way to circumvent this limit
@c is to tell @code{etags} to read the file names from its standard input,
@c by typing a dash in place of the file names, like this:
非常に多数のファイルからタグテーブルを作成する場合、
コマンド行の長さを制限しているシステムもあるので、
ファイル名をコマンドラインで指定するときに問題が起こる可能性があります。
この制限を回避するもっとも単純な方法は、
つぎのように、ファイル名を指定する位置にダッシュを打って、
@code{etags}に標準入力からファイル名を読み込ませることです。

@example
find . -name "*.[chCH]" -print | etags -
@end example

@c   Use the option @samp{--language=@var{name}} to specify the language
@c explicitly.  You can intermix these options with file names; each one
@c applies to the file names that follow it.  Specify
@c @samp{--language=auto} to tell @code{etags} to resume guessing the
@c language from the file names and file contents.  Specify
@c @samp{--language=none} to turn off language-specific processing
@c entirely; then @code{etags} recognizes tags by regexp matching alone.
@c @samp{etags --help} prints the list of the languages @code{etags} knows,
@c and the file name rules for guessing the language.
オプション@samp{--language=@var{name}}を使えば、
言語を明示的に指定できます。
このオプションはファイル名と混ぜていくつでも使用できます。
それぞれ、あとに続くファイル名に適用されます。
@samp{--language=auto}を指定すると、
@code{etags}はファイル名とその内容からふたたび使用言語を推測します。
@samp{--language=none}を指定すれば、
言語に依存した処理をいっさい行わないようになります。
すると、@code{etags}は正規表現による一致だけに
基づいてタグを認識します。
@code{etags}が知っている言語と、言語を推測するファイル名規則を表示するには、
@samp{etags --help}を指定します。

@c   The @samp{--regex} option provides a general way of recognizing tags
@c based on regexp matching.  You can freely intermix it with file names.
@c Each @samp{--regex} option adds to the preceding ones, and applies only
@c to the following files.  The syntax is:
@samp{--regex}オプションは、
正規表現による一致に基づいてタグを認識させる一般的な方法です。
このオプションとファイル名を自由に混ぜて使用できます。
各@samp{--regex}オプションは、それ以前に指定した正規表現に追加され、
オプションのあとにあるファイルに適用されます。
オプションの構文はつぎのとおりです。

@example
--regex=/@var{tagregexp}[/@var{nameregexp}]/
@end example

@noindent
@c where @var{tagregexp} is used to match the lines to tag.  It is always
@c anchored, that is, it behaves as if preceded by @samp{^}.  If you want
@c to account for indentation, just match any initial number of blanks by
@c beginning your regular expression with @samp{[ \t]*}.  In the regular
@c expressions, @samp{\} quotes the next character, and @samp{\t} stands
@c for the tab character.  Note that @code{etags} does not handle the other
@c C escape sequences for special characters.
ここで、@var{tagregexp}は、行に一致させてタグを取り出すために使われます。
これはつねに位置が固定されています。
つまり、@samp{^}が前置されているかのように扱われます。
字下げ分を考慮したければ、正規表現を@samp{[ \t]*}で始めて、
行頭の任意個の空白に一致するようにします。
正規表現においては、@samp{\}は直後の文字をクォートし、
@samp{\t}はタブ文字を表します。
@code{etags}では、これら以外にはCで使われるエスケープシーケンスを
扱えないことに注意してください。

@c @cindex interval operator (in regexps)
@cindex 反復回数演算子(正規表現)
@c   The syntax of regular expressions in @code{etags} is the same as in
@c Emacs, augmented with the @dfn{interval operator}, which works as in
@c @code{grep} and @code{ed}.  The syntax of an interval operator is
@c @samp{\@{@var{m},@var{n}\@}}, and its meaning is to match the preceding
@c expression at least @var{m} times and up to @var{n} times.
@code{etags}の正規表現の構文は、Emacsのものと同じで、
@dfn{反復回数演算子}(interval operator)が拡張されています。
この演算子は、@code{grep}や@code{ed}で使えるものと同じ動作をします。
反復回数演算子の構文は@samp{\@{@var{m},@var{n}\@}}であり、
直前の正規表現の@var{m}回以上@var{n}回以下の繰り返しに一致します。

@c   You should not match more characters with @var{tagregexp} than that
@c needed to recognize what you want to tag.  If the match is such that
@c more characters than needed are unavoidably matched by @var{tagregexp},
@c you may find useful to add a @var{nameregexp}, in order to narrow the tag
@c scope.  You can find some examples below.
@var{tagregexp}がタグとして認識したい部分よりも長く一致するようには
しないでください。
@var{tagregexp}に一致する部分が必要以上に長くなるのが避けられないならば、
タグの範囲を狭めるために@var{nameregexp}を追加するとよいかもしれません。
正規表現を利用した例をいくつか紹介しましょう。

@c   The @samp{-R} option deletes all the regexps defined with
@c @samp{--regex} options.  It applies to the file names following it, as
@c you can see from the following example:
@samp{-R}オプションは、それまでに@samp{--regex}オプションで定義した
すべての正規表現を削除します。
つぎの使用例からもわかるように、
オプションのあとに続くファイルに適用されます。

@example
etags --regex=/@var{reg1}/ voo.doo --regex=/@var{reg2}/ \
    bar.ber -R --lang=lisp los.er
@end example

@noindent
@c Here @code{etags} chooses the parsing language for @file{voo.doo} and
@c @file{bar.ber} according to their contents.  @code{etags} also uses
@c @var{reg1} to recognize additional tags in @file{voo.doo}, and both
@c @var{reg1} and @var{reg2} to recognize additional tags in
@c @file{bar.ber}.  @code{etags} uses the Lisp tags rules, and no regexp
@c matching, to recognize tags in @file{los.er}.
この例では、@code{etags}は、
@file{voo.doo}と@file{bar.ber}に対しては、その内容から使用言語を推定します。
さらに、@file{voo.doo}から余分にタグを認識するために@var{reg1}を使い、
@file{bar.ber}から余分にタグを認識するためには
@var{reg1}と@var{reg2}の両方を使います。
@file{los.er}からタグを認識するには、
Lispのタグ構文規則だけを使い、正規表現による一致はいっさい使いません。

@c   Here are some more examples.  The regexps are quoted to protect them
@c from shell interpretation.
別の例を示しましょう。
ここでは、シェルが解釈しないように正規表現をクォートします。

@itemize @bullet
@item
@c Tag the @code{DEFVAR} macros in the emacs source files:
Emacsのソースファイルに含まれる@code{DEFVAR}マクロをタグとする。

@smallexample
--regex='/[ \t]*DEFVAR_[A-Z_ \t(]+"\([^"]+\)"/'
@end smallexample

@item
@c Tag VHDL files (this example is a single long line, broken here for
@c formatting reasons):
VHDLファイルからタグを取り出す
(この例は本来は単一の長い行だが、印刷の関係で分割してある)。

@smallexample
--language=none
--regex='/[ \t]*\(ARCHITECTURE\|CONFIGURATION\) +[^ ]* +OF/'
--regex='/[ \t]*\(ATTRIBUTE\|ENTITY\|FUNCTION\|PACKAGE\
\( BODY\)?\|PROCEDURE\|PROCESS\|TYPE\)[ \t]+\([^ \t(]+\)/\3/'
@end smallexample

@item
@c Tag Tcl files (this last example shows the usage of a @var{nameregexp}):
Tclファイルからタグを取り出す
(この例は@var{nameregexp}の使用例でもある)。

@smallexample
--lang=none --regex='/proc[ \t]+\([^ \t]+\)/\1/'
@end smallexample
@end itemize

@c   For a list of the other available @code{etags} options, execute
@c @code{etags --help}.
他のオプション一覧を表示するには、
@code{etags --help}を実行してください。

@node Select Tags Table, Find Tag, Create Tags Table, Tags
@c @subsection Selecting a Tags Table
@subsection タグテーブルの選択

@vindex tags-file-name
@findex visit-tags-table
@c   Emacs has at any time one @dfn{selected} tags table, and all the commands
@c for working with tags tables use the selected one.  To select a tags table,
@c type @kbd{M-x visit-tags-table}, which reads the tags table file name as an
@c argument.  The name @file{TAGS} in the default directory is used as the
@c default file name.
Emacsでは、いつでも1つの@dfn{選択された}タグテーブルがあり、
タグテーブルを使って動作するコマンドは選択されたタグテーブルを使用します。
タグテーブルを選択するには、@kbd{M-x visit-tags-table}と打ちます。
すると、タグテーブルファイル名を聞いてきます。
デフォルトのファイル名は、デフォルトディレクトリの@file{TAGS}です。

@c   All this command does is store the file name in the variable
@c @code{tags-file-name}.  Emacs does not actually read in the tags table
@c contents until you try to use them.  Setting this variable yourself is just
@c as good as using @code{visit-tags-table}.  The variable's initial value is
@c @code{nil}; that value tells all the commands for working with tags tables
@c that they must ask for a tags table file name to use.
このコマンドは、ファイル名を変数@code{tags-file-name}に格納するだけです。
タグテーブルを使おうとしない限り、
Emacsは実際にはタグテーブルの内容を読み込みません。
@code{visit-tags-table}を使わずに、
自分自身でこの変数にファイル名を設定してもかまいません。
この変数の初期値は@code{nil}です。
これは、タグテーブルを使うすべてのコマンドに、
使用するタグテーブルファイルを尋ねさせることになります。

@c   Using @code{visit-tags-table} when a tags table is already loaded
@c gives you a choice: you can add the new tags table to the current list
@c of tags tables, or start a new list.  The tags commands use all the tags
@c tables in the current list.  If you start a new list, the new tags table
@c is used @emph{instead} of others.  If you add the new table to the
@c current list, it is used @emph{as well as} the others.  When the tags
@c commands scan the list of tags tables, they don't always start at the
@c beginning of the list; they start with the first tags table (if any)
@c that describes the current file, proceed from there to the end of the
@c list, and then scan from the beginning of the list until they have
@c covered all the tables in the list.
すでにタグテーブルを読み込んであるときに@code{visit-tags-table}を使うと、
2つの選択肢があります。
現在のタグテーブルリストに新たにタグテーブルを追加するか、
タグテーブルリストを新規に始めるかです。
タグコマンドは、現在のリストにあるすべてのタグテーブルを使用します。
新たなタグテーブルリストを始めると、他のタグテーブルの@emph{かわり}に
新たなタグテーブルが使われます。
現在のリストに新たなタグテーブルを追加すると、
他のタグテーブルと@emph{ともに}新たなものも使われます。
タグコマンドがタグテーブルリストを走査するときには、
つねにリストの先頭から始めるわけではありません。
現在のファイルを記録しているタグテーブルがあれば、
まずそれから始めてリストの末尾まで進みます。
そして、リストの先頭からリストに含まれる
すべてのタグテーブルを調べ終るまで走査を続けます。

@vindex tags-table-list
@c   You can specify a precise list of tags tables by setting the variable
@c @code{tags-table-list} to a list of strings, like this:
変数@code{tags-table-list}に文字列のリストを設定すれば、
タグテーブルの正確なリストをあらかじめ指定できます。
たとえば、つぎのようにします。

@c keep this on two lines for formatting in smallbook
@example
@group
(setq tags-table-list
      '("~/emacs" "/usr/local/lib/emacs/src"))
@end group
@end example

@noindent
@c This tells the tags commands to look at the @file{TAGS} files in your
@c @file{~/emacs} directory and in the @file{/usr/local/lib/emacs/src}
@c directory.  The order depends on which file you are in and which tags
@c table mentions that file, as explained above.
この設定例では、タグコマンドは、
個人の@file{~/emacs}ディレクトリと
@file{/usr/local/lib/emacs/src}ディレクトリの
(2つの)@file{TAGS}ファイルを見にいきます。
上で述べたように、タグファイルを使う順番は、
対象としているファイルやそのファイルを記述しているタグテーブルに依存します。

@c   Do not set both @code{tags-file-name} and @code{tags-table-list}.
@code{tags-file-name}と@code{tags-table-list}の両方に
値を設定してはいけません。

@node Find Tag, Tags Search, Select Tags Table, Tags
@c @subsection Finding a Tag
@subsection タグの探索

@c   The most important thing that a tags table enables you to do is to find
@c the definition of a specific tag.
タグテーブルで実現されるもっとも重要な機能は、
指定したタグの定義を探し出すことです。

@table @kbd
@item M-.@: @var{tag} @key{RET}
@c Find first definition of @var{tag} (@code{find-tag}).
タグ@var{tag}の最初の定義を探す(@code{find-tag})。
@item C-u M-.
@c Find next alternate definition of last tag specified.
最後に指定したタグのつぎの定義を探す。
@item C-u - M-.
@c Go back to previous tag found.
まえにみつかったタグに戻る。
@item C-M-. @var{pattern} @key{RET}
@c Find a tag whose name matches @var{pattern} (@code{find-tag-regexp}).
名前が@var{pattern}に一致するタグを探す(@code{find-tag-regexp})。
@item C-u C-M-.
@c Find the next tag whose name matches the last pattern used.
最後に使用したパターンに一致するつぎのタグを探する。
@item C-x 4 .@: @var{tag} @key{RET}
@c Find first definition of @var{tag}, but display it in another window
@c (@code{find-tag-other-window}).
タグ@var{tag}の最初の定義を探し、
別のウィンドウに表示する(@code{find-tag-other-window})。
@item C-x 5 .@: @var{tag} @key{RET}
@c Find first definition of @var{tag}, and create a new frame to select the
@c buffer (@code{find-tag-other-frame}).
タグ@var{tag}の最初の定義を探し、
バッファを選択するための新たなフレームを作る。
(@code{find-tag-other-frame})。
@item M-*
@c Pop back to where you previously invoked @kbd{M-.} and friends.
まえに@kbd{M-.}を起動した場所へ戻る。
@end table

@kindex M-.
@findex find-tag
@c   @kbd{M-.}@: (@code{find-tag}) is the command to find the definition of
@c a specified tag.  It searches through the tags table for that tag, as a
@c string, and then uses the tags table info to determine the file that the
@c definition is in and the approximate character position in the file of
@c the definition.  Then @code{find-tag} visits that file, moves point to
@c the approximate character position, and searches ever-increasing
@c distances away to find the tag definition.
@kbd{M-.}@:(@code{find-tag})は、指定したタグの定義を探すコマンドです。
まず、タグテーブルの中で文字列としてタグ名を探し、
タグテーブルの情報を用いて、
定義されているファイルの名前とファイル内でのおおよその文字位置を求めます。
続いて、@code{find-tag}はそのソースファイルを訪れて、
ポイントをおおよその文字位置に移動してから、
範囲を広げながらタグの定義を探します。

@c   If an empty argument is given (just type @key{RET}), the sexp in the
@c buffer before or around point is used as the @var{tag} argument.
@c @xref{Lists}, for info on sexps.
(単に@key{RET}と打って)引数を指定しないと、
ポイントの直前または周辺にあるS式を@var{tag}引数として使います。
S式に関しては、@xref{Lists}。

@c   You don't need to give @kbd{M-.} the full name of the tag; a part
@c will do.  This is because @kbd{M-.} finds tags in the table which
@c contain @var{tag} as a substring.  However, it prefers an exact match
@c to a substring match.  To find other tags that match the same
@c substring, give @code{find-tag} a numeric argument, as in @kbd{C-u
@c M-.}; this does not read a tag name, but continues searching the tags
@c table's text for another tag containing the same substring last used.
@c If you have a real @key{META} key, @kbd{M-0 M-.}@: is an easier
@c alternative to @kbd{C-u M-.}.
コマンド@kbd{M-.}にタグの名前を完全に与える必要はありません。
その一部分で十分です。
というのは、@kbd{M-.}は、部分文字列として@var{tag}を含む
タグをタグテーブルで探すからです。
もちろん、部分一致よりも全一致のほうが望ましいです。
同じ部分文字列に一致する別のタグを探すには、
@kbd{C-u M-.}のように@code{find-tag}に数引数を指定します。
こうするとタグ名を聞いてきませんが、
最後に使ったものと同じ部分文字列を含む別のタグを
タグテーブルから探します。
もし本物の@key{META}キーが使えるのであれば、
@kbd{C-u M-.}のかわりに@kbd{M-0 M-.}@:と打つほうが簡単でしょう。

@kindex C-x 4 .
@findex find-tag-other-window
@kindex C-x 5 .
@findex find-tag-other-frame
@c   Like most commands that can switch buffers, @code{find-tag} has a
@c variant that displays the new buffer in another window, and one that
@c makes a new frame for it.  The former is @kbd{C-x 4 .}, which invokes
@c the command @code{find-tag-other-window}.  The latter is @kbd{C-x 5 .},
@c which invokes @code{find-tag-other-frame}.
バッファの切り替えを伴う他のコマンドと同様に、
@code{find-tag}にも新たなバッファを別のウィンドウに表示したり、
新規作成したフレームに表示する変種があります。
前者は@kbd{C-x 4 .}であり、コマンド@code{find-tag-other-window}を起動します。
後者は@kbd{C-x 5 .}であり、@code{find-tag-other-frame}を起動します。

@c   To move back to places you've found tags recently, use @kbd{C-u -
@c M-.}; more generally, @kbd{M-.} with a negative numeric argument.  This
@c command can take you to another buffer.  @kbd{C-x 4 .} with a negative
@c argument finds the previous tag location in another window.
最近にみつけたタグ位置に戻るには、@kbd{C-u - M-.}を使います。
より一般的には、@kbd{M-.}に負の数引数を指定します。
このコマンドは、別のバッファへも移動します。
@kbd{C-x 4 .}に負の数引数を指定すると、
別のウィンドウでまえのタグ位置に戻ります。

@kindex M-*
@findex pop-tag-mark
@vindex find-tag-marker-ring-length
@c   As well as going back to places you've found tags recently, you can go
@c back to places @emph{from where} you found them.  Use @kbd{M-*}, which
@c invokes the command @code{pop-tag-mark}, for this.  Typically you would
@c find and study the definition of something with @kbd{M-.} and then
@c return to where you were with @kbd{M-*}.
最近にみつけたタグ位置に戻るだけでなく、
タグを@emph{探したとき}の場所へ戻ることもできます。
それには、コマンド@code{pop-tag-mark}を起動する@kbd{M-*}を使います。
典型的な使い方では、@kbd{M-.}で何かの定義を調べてから、
@kbd{M-*}でもとの場所に戻ります。

@c   Both @kbd{C-u - M-.} and @kbd{M-*} allow you to retrace your steps to
@c a depth determined by the variable @code{find-tag-marker-ring-length}.
@kbd{C-u - M-.}と@kbd{M-*}のどちらも、
変数@code{find-tag-marker-ring-length}で指定される深さまで、
辿った経路を引き返せます。

@findex find-tag-regexp
@kindex C-M-.
@c   The command @kbd{C-M-.} (@code{find-tag-regexp}) visits the tags that
@c match a specified regular expression.  It is just like @kbd{M-.} except
@c that it does regexp matching instead of substring matching.
コマンド@kbd{C-M-.}(@code{find-tag-regexp})は、
指定した正規表現に一致するタグを訪れます。
部分文字列ではなく正規表現に一致するものであることを除けば、
@kbd{M-.}と同じです。

@node Tags Search, List Tags, Find Tag, Tags
@c @subsection Searching and Replacing with Tags Tables
@subsection タグテーブルを用いた探索と置換

@c   The commands in this section visit and search all the files listed in the
@c selected tags table, one by one.  For these commands, the tags table serves
@c only to specify a sequence of files to search.
ここで紹介するコマンドは、選択されたタグテーブルに記録されている
すべてのファイルを1つ1つ訪れては探索を行います。
これらのコマンドに対しては、タグテーブルは探索対象となる
一連のファイルを指定するだけです。

@table @kbd
@item M-x tags-search @key{RET} @var{regexp} @key{RET}
@c Search for @var{regexp} through the files in the selected tags
@c table.
選択されたタグテーブル内の各ファイルから
指定された@var{正規表現}を探索する。
@item M-x tags-query-replace @key{RET} @var{regexp} @key{RET} @var{replacement} @key{RET}
@c Perform a @code{query-replace-regexp} on each file in the selected tags table.
選択されたタグテーブル内の各ファイルに対して、
@code{query-replace-regexp}を実行する。
@item M-,
@c Restart one of the commands above, from the current location of point
@c (@code{tags-loop-continue}).
ポイント位置から上記のコマンドのいずれかを再実行する
(@code{tags-loop-continue})。
@end table

@findex tags-search
@c   @kbd{M-x tags-search} reads a regexp using the minibuffer, then
@c searches for matches in all the files in the selected tags table, one
@c file at a time.  It displays the name of the file being searched so you
@c can follow its progress.  As soon as it finds an occurrence,
@c @code{tags-search} returns.
@kbd{M-x tags-search}は、ミニバッファで正規表現を読み取り、
選択されたタグテーブル内のすべてのファイル1つ1つについて、
正規表現に一致する部分を探します。
このコマンドは探索しているファイル名を表示するので、
進行状況がわかります。
正規表現に一致する部分がみつかると、@code{tags-search}はすぐに戻ります。

@kindex M-,
@findex tags-loop-continue
@c   Having found one match, you probably want to find all the rest.  To find
@c one more match, type @kbd{M-,} (@code{tags-loop-continue}) to resume the
@c @code{tags-search}.  This searches the rest of the current buffer, followed
@c by the remaining files of the tags table.@refill
一致する部分をみつけたあとに、残りも探したくなるでしょう。
つぎの一致を探すには、
@kbd{M-,}(@code{tags-loop-continue})と打って、
@code{tags-search}を再開します。
これは、カレントバッファの残りを探索してから、
タグテーブルの残りのファイルについても探索します。

@findex tags-query-replace
@c   @kbd{M-x tags-query-replace} performs a single
@c @code{query-replace-regexp} through all the files in the tags table.  It
@c reads a regexp to search for and a string to replace with, just like
@c ordinary @kbd{M-x query-replace-regexp}.  It searches much like @kbd{M-x
@c tags-search}, but repeatedly, processing matches according to your
@c input.  @xref{Replace}, for more information on query replace.
@kbd{M-x tags-query-replace}は、タグテーブル内のすべてのファイルを対象に、
@code{query-replace-regexp}を実行します。
このコマンドは、通常の@kbd{M-x query-replace-regexp}
(問い合わせ型置換)と同じく、
探索すべき正規表現と置換文字列を読み取ります。
そして、@kbd{M-x tags-search}のように探索を行い、
利用者の入力に応じて一致部分を処理することを繰り返します。
問い合わせ型置換について詳しくは、@xref{Replace}。

@c   It is possible to get through all the files in the tags table with a
@c single invocation of @kbd{M-x tags-query-replace}.  But often it is
@c useful to exit temporarily, which you can do with any input event that
@c has no special query replace meaning.  You can resume the query replace
@c subsequently by typing @kbd{M-,}; this command resumes the last tags
@c search or replace command that you did.
@kbd{M-x tags-query-replace}を一度起動するだけで、
タグテーブル内の全ファイルの置換を行うことができます。
しかし、一時的に置換作業から抜け出して、
問い合わせ型置換とは関係ないことを行えると便利です。
@kbd{M-,}と打てば、問い合わせ型置換を再開できます。
このコマンドは、最後に行ったタグの探索コマンドか置換コマンドを
再開します。

@c   The commands in this section carry out much broader searches than the
@c @code{find-tag} family.  The @code{find-tag} commands search only for
@c definitions of tags that match your substring or regexp.  The commands
@c @code{tags-search} and @code{tags-query-replace} find every occurrence
@c of the regexp, as ordinary search commands and replace commands do in
@c the current buffer.
ここで紹介したコマンドは、@code{find-tag}系列のコマンドよりも、
幅広い探索を実行します。
@code{find-tag}コマンドは、指定した部分文字列や正規表現に一致する
タグの定義だけをみつけます。
コマンド@code{tags-search}と@code{tags-query-replace}は、
通常の探索コマンドや置換コマンドがカレントバッファで行うように、
正規表現に一致するあらゆる部分を探し出します。

@c   These commands create buffers only temporarily for the files that they
@c have to search (those which are not already visited in Emacs buffers).
@c Buffers in which no match is found are quickly killed; the others
@c continue to exist.
これらのコマンドは、(Emacsバッファにまだ訪れていないものに対しては)
探索すべきファイル用に一時的なバッファを作成します。
一致部分がみつからなければバッファはただちに消されますが、
みつかれば存続します。

@c   It may have struck you that @code{tags-search} is a lot like
@c @code{grep}.  You can also run @code{grep} itself as an inferior of
@c Emacs and have Emacs show you the matching lines one by one.  This works
@c much like running a compilation; finding the source locations of the
@c @code{grep} matches works like finding the compilation errors.
@c @xref{Compilation}.
@code{tags-search}は、@code{grep}プログラムにたいへんよく似ていると
思われたかもしれません。
Emacsの下位プロセスとして@code{grep}を実行して、
Emacsに一致した行を1つずつ表示させることもできます。
これは、コンパイルを実行するのと同じように動作します。
@code{grep}が一致を検出したソース箇所を探すことは、
コンパイルエラーを探すのと同様に動作します。
@xref{Compilation}。
        
@node List Tags,  , Tags Search, Tags
@c @subsection Tags Table Inquiries
@subsection タグテーブルの照会

@table @kbd
@item M-x list-tags @key{RET} @var{file} @key{RET}
@c Display a list of the tags defined in the program file @var{file}.
プログラムファイル@var{file}で定義されているタグの一覧を表示する。
@item M-x tags-apropos @key{RET} @var{regexp} @key{RET}
@c Display a list of all tags matching @var{regexp}.
@var{regexp}に一致するすべてのタグを表示する。
@end table

@findex list-tags
@c   @kbd{M-x list-tags} reads the name of one of the files described by
@c the selected tags table, and displays a list of all the tags defined in
@c that file.  The ``file name'' argument is really just a string to
@c compare against the file names recorded in the tags table; it is read as
@c a string rather than as a file name.  Therefore, completion and
@c defaulting are not available, and you must enter the file name the same
@c way it appears in the tags table.  Do not include a directory as part of
@c the file name unless the file name recorded in the tags table includes a
@c directory.
@kbd{M-x list-tags}は、選択されたタグテーブルに記載されている
ファイルのどれか1つのファイル名を読み取り、
そのファイルで定義されているすべてのタグを表示します。
引数の『ファイル名』は、タグテーブルに記録されたファイル名と
単純に文字列として比較されます。
ファイル名というよりは、文字列として読まれます。
したがって、補完やデフォルトはありませんし、
タグテーブルに格納されているとおりに正確にファイル名を入力する必要があります。
タグテーブル内のファイル名にディレクトリが含まれない限り、
ファイル名にもディレクトリを含めてはいけません。

@findex tags-apropos
@c   @kbd{M-x tags-apropos} is like @code{apropos} for tags
@c (@pxref{Apropos}).  It reads a regexp, then finds all the tags in the
@c selected tags table whose entries match that regexp, and displays the
@c tag names found.
@kbd{M-x tags-appropos}は、タグに対する@code{apropos}にあたります 
(@pxref{Apropos})。
このコマンドは、正規表現を読み取り、
選択されたタグテーブルの中から正規表現に一致する項目のタグを
すべてみつけだし、そのタグ名を表示します。

@c   You can also perform completion in the buffer on the name space of tag
@c names in the current tags tables.  @xref{Symbol Completion}.
現在のタグテーブルに含まれるタグ名を名前空間として、
バッファ内で補完を行うこともできます。
@xref{Symbol Completion}。

@node Emerge, C Modes, Tags, Programs
@c @section Merging Files with Emerge
@section emergeを用いたファイルの併合
@c @cindex Emerge
@cindex emerge
@c @cindex merging files
@cindex ファイルの併合

@c It's not unusual for programmers to get their signals crossed and modify
@c the same program in two different directions.  To recover from this
@c confusion, you need to merge the two versions.  Emerge makes this
@c easier.  See also @ref{Comparing Files}, for commands to compare
@c in a more manual fashion, and @ref{Emerge,,, ediff, The Ediff Manual}.
ちょっとしたミスで、1つのプログラムから2つの別の版を
作ってしまうこともあります。
この混乱した状態を収拾するには、それらを併合する必要があります。
emergeを使うと、併合作業が容易になります。
手動で比較するコマンドについては、@ref{Comparing Files}と
@ref{Emerge,,, ediff, The Ediff Manual}を参照してください。

@menu
* Overview of Emerge::	How to start Emerge.  Basic concepts.
* Submodes of Emerge::	Fast mode vs. Edit mode.
			  Skip Prefers mode and Auto Advance mode.
* State of Difference::	You do the merge by specifying state A or B
			  for each difference.
* Merge Commands::	Commands for selecting a difference,
			  changing states of differences, etc.
* Exiting Emerge::	What to do when you've finished the merge.
* Combining in Emerge::	    How to keep both alternatives for a difference.
* Fine Points of Emerge::   Misc.
@end menu

@node Overview of Emerge, Submodes of Emerge, , Emerge
@c @subsection Overview of Emerge
@subsection emergeの概要

@c To start Emerge, run one of these four commands:
以下の4つのコマンドのいずれかでemergeを実行します。

@table @kbd
@item M-x emerge-files
@findex emerge-files
@c Merge two specified files.
指定した2つのファイルを併合する。

@item M-x emerge-files-with-ancestor
@findex emerge-files-with-ancestor
@c Merge two specified files, with reference to a common ancestor.
共通の祖先を参照しながら、指定した2つのファイルを併合する。

@item M-x emerge-buffers
@findex emerge-buffers
@c Merge two buffers.
2つのバッファを併合する。

@item M-x emerge-buffers-with-ancestor
@findex emerge-buffers-with-ancestor
@c Merge two buffers with reference to a common ancestor in a third
@c buffer.
3番目のバッファに入っている共通の祖先を参照しながら、2つのバッファを併合する。
@end table

@c @cindex merge buffer (Emerge)
@c @cindex A and B buffers (Emerge)
@cindex 併合バッファ(emerge)
@cindex AバッファとBバッファ(emerge)
@c   The Emerge commands compare two files or buffers, and display the
@c comparison in three buffers: one for each input text (the @dfn{A buffer}
@c and the @dfn{B buffer}), and one (the @dfn{merge buffer}) where merging
@c takes place.  The merge buffer shows the full merged text, not just the
@c differences.  Wherever the two input texts differ, you can choose which
@c one of them to include in the merge buffer.
emergeコマンドは、2つのファイル、あるいは、2つのバッファを比較して、
比較結果を3つのバッファ、つまり、
各入力テキストに1つずつ(@dfn{Aバッファ}と@dfn{Bバッファ})と、
併合を実施するバッファ(@dfn{併合バッファ})に表示します。
併合バッファには、比較によって得られる差分だけでなく、
併合したテキスト全体が表示されます。
2つの入力テキストが相違している箇所については、
どちらのテキストを併合バッファに含めるか選択できます。

@c   The Emerge commands that take input from existing buffers use only the
@c accessible portions of those buffers, if they are narrowed
@c (@pxref{Narrowing}).
既存のバッファを入力源とするemergeコマンドでは、
入力バッファがナロイングされていると、
バッファの参照可能な部分だけを使います(@pxref{Narrowing})。

@c   If a common ancestor version is available, from which the two texts to
@c be merged were both derived, Emerge can use it to guess which
@c alternative is right.  Wherever one current version agrees with the
@c ancestor, Emerge presumes that the other current version is a deliberate
@c change which should be kept in the merged version.  Use the
@c @samp{with-ancestor} commands if you want to specify a common ancestor
@c text.  These commands read three file or buffer names---variant A,
@c variant B, and the common ancestor.
併合したい2つのテキストのもとである共通の祖先にあたる版を利用できるときには、
emergeはそれを使ってどちらの選択肢が正しいのか推測します。
一方の入力と祖先との一致部分がどこかにあれば、
もう一方の入力には併合結果に残すべき意図的な変更がなされていると推測します。
共通の祖先のテキストを指定するには、
名前に@samp{with-ancestor}の付いたコマンドを使ってください。
これらのコマンドは、A版、B版、共通の祖先に対応する
3つのファイル名かバッファ名を読み取ります。

@c   After the comparison is done and the buffers are prepared, the
@c interactive merging starts.  You control the merging by typing special
@c @dfn{merge commands} in the merge buffer.  The merge buffer shows you a
@c full merged text, not just differences.  For each run of differences
@c between the input texts, you can choose which one of them to keep, or
@c edit them both together.
入力を比較してバッファの準備を終えると、つぎは対話的な併合作業が始まります。
併合バッファで特別な@dfn{併合コマンド}を打って併合作業を制御します。
併合バッファには、単なる差分ではなく併合したテキスト全体が表示されます。
入力テキストの各相違箇所に対して、どちら側を残すか選択したり、
両者をもとにして編集できます。

@c   The merge buffer uses a special major mode, Emerge mode, with commands
@c for making these choices.  But you can also edit the buffer with
@c ordinary Emacs commands.
併合バッファでは、emergeモードと呼ばれる特別なメジャーモードが使われ、
これらを選択するコマンドがあります。
もちろん、通常のEmacsコマンドでバッファを編集することもできます。

@c   At any given time, the attention of Emerge is focused on one
@c particular difference, called the @dfn{selected} difference.  This
@c difference is marked off in the three buffers like this:
emergeの注意は、いつでも@dfn{注目}相違箇所と呼ばれる
相違箇所に向けられています。
3つのバッファ内では、注目相違点はつぎのように印が付けられます。

@example
vvvvvvvvvvvvvvvvvvvv
@var{text that differs}
^^^^^^^^^^^^^^^^^^^^
@end example

@noindent
@c Emerge numbers all the differences sequentially and the mode
@c line always shows the number of the selected difference.
emergeはすべての相違箇所に順に番号をふります。
さらに、モード行にはつねに注目相違箇所の番号が表示されます。

@c   Normally, the merge buffer starts out with the A version of the text.
@c But when the A version of a difference agrees with the common ancestor,
@c then the B version is initially preferred for that difference.
通常、併合バッファはA版の内容で始まります。
しかし、A版の内容が共通の祖先の内容と一致するときには、
併合バッファはB版の内容で始まります。

@c   Emerge leaves the merged text in the merge buffer when you exit.  At
@c that point, you can save it in a file with @kbd{C-x C-w}.  If you give a
@c numeric argument to @code{emerge-files} or
@c @code{emerge-files-with-ancestor}, it reads the name of the output file
@c using the minibuffer.  (This is the last file name those commands read.)
@c Then exiting from Emerge saves the merged text in the output file.
emergeを終えると、併合バッファにはその時点の併合済みテキストが残ります。
emerge終了時には、@kbd{C-x C-w}でファイルに保存できます。
@code{emerge-files}や@code{emerge-files-with-ancestor}に
数引数を指定すると、ミニバッファで出力ファイル名を読み取ります。
(どちらの場合でも、これがいちばん最後に聞かれるファイル名。)
すると、emerge終了時には、併合済みのテキストがその出力ファイルに保存されます。

@c   Normally, Emerge commands save the output buffer in its file when you
@c exit.  If you abort Emerge with @kbd{C-]}, the Emerge command does not
@c save the output buffer, but you can save it yourself if you wish.
emergeを終えると、通常、emergeコマンドが併合バッファをファイルに保存します。
emergeを@kbd{C-]}でアボートするとemergeコマンドは併合バッファを保存しませんが、
必要ならばユーザー自身で保存できます。

@node Submodes of Emerge, State of Difference, Overview of Emerge, Emerge
@c @subsection Submodes of Emerge
@subsection emergeのサブモード

@c   You can choose between two modes for giving merge commands: Fast mode
@c and Edit mode.  In Fast mode, basic merge commands are single
@c characters, but ordinary Emacs commands are disabled.  This is
@c convenient if you use only merge commands.  In Edit mode, all merge
@c commands start with the prefix key @kbd{C-c C-c}, and the normal Emacs
@c commands are also available.  This allows editing the merge buffer, but
@c slows down Emerge operations.
併合コマンドを指示するためのモードが2つ、つまり、
高速モード(Fast mode)と編集モード(Edit mode)があり、どちらかを選べます。
高速モードでは、基本的な併合コマンドは1文字で表され、
通常のEmacsコマンドは禁止されています。
併合コマンドだけを使用するのであれば、高速モードが便利です。
編集モードでは、すべての併合コマンドはプレフィックス@kbd{C-c C-c}で始まり、
通常のEmacsコマンドも使えます。
このモードでは、併合バッファを編集できますが、emergeの処理は遅くなります。

@c   Use @kbd{e} to switch to Edit mode, and @kbd{C-c C-c f} to switch to
@c Fast mode.  The mode line indicates Edit and Fast modes with @samp{E}
@c and @samp{F}.
編集モードに切り替えるには@kbd{e}を使い、
高速モードに切り替えるには@kbd{C-c C-c f}を使います。
モード行には、編集モードは@samp{E}、高速モードは@samp{F}と表示されます。

@c   Emerge has two additional submodes that affect how particular merge
@c commands work: Auto Advance mode and Skip Prefers mode.
emergeには、特定の併合コマンドの動作に影響を与えるサブモードが
さらに2つあります。
自動前進(auto-advance)モードと
優先箇所スキップ(skip-prefers)モードです。

@c   If Auto Advance mode is in effect, the @kbd{a} and @kbd{b} commands
@c advance to the next difference.  This lets you go through the merge
@c faster as long as you simply choose one of the alternatives from the
@c input.  The mode line indicates Auto Advance mode with @samp{A}.
自動前進モードがオンであると、コマンド@kbd{a}と@kbd{b}は、
自動的につぎの相違箇所にポイントを進めます。
このモードでは、どちらかの入力だけを選ぶ状況である限り、高速に併合を行えます。
モード行には@samp{A}と表示され、自動前進モードであるを示します。

@c   If Skip Prefers mode is in effect, the @kbd{n} and @kbd{p} commands
@c skip over differences in states prefer-A and prefer-B (@pxref{State of
@c Difference}).  Thus you see only differences for which neither version
@c is presumed ``correct.''  The mode line indicates Skip Prefers mode with
@c @samp{S}.
優先箇所スキップモードがオンであると、
コマンド@kbd{n}と@kbd{p}は、
A優先/B優先の状態にある相違箇所をスキップします
(@pxref{State of Difference})。
つまり、どちらの版も『正しい』と推定されない相違箇所だけを調べことになります。
モード行には@samp{S}と表示され、優先箇所スキップモードであることを示します。

@findex emerge-auto-advance-mode
@findex emerge-skip-prefers-mode
@c   Use the command @kbd{s a} (@code{emerge-auto-advance-mode}) to set or
@c clear Auto Advance mode.  Use @kbd{s s}
@c (@code{emerge-skip-prefers-mode}) to set or clear Skip Prefers mode.
@c These commands turn on the mode with a positive argument, turns it off
@c with a negative or zero argument, and toggle the mode with no argument.
自動前進モードをオン/オフするには、
コマンド@kbd{s a}(@code{emerge-auto-advance-mode})を使います。
優先箇所スキップモードをオン/オフするには、
コマンド@kbd{s s}(@code{emerge-skip-prefers-mode})を使います。
どちらのコマンドも、正の数引数を指定するとオンにし、
負あるいは0の数引数を指定するとオフにし、
引数を指定しないとトグル(切り替え)します。

@node State of Difference, Merge Commands, Submodes of Emerge, Emerge
@c @subsection State of a Difference
@subsection 相違箇所の状態

@c   In the merge buffer, a difference is marked with lines of @samp{v} and
@c @samp{^} characters.  Each difference has one of these seven states:
併合バッファ内では、相違箇所は@samp{v}と@samp{^}の文字だけの行に
挟まれて示されます。
各相違箇所は、つぎの7つのいずれかの状態になっています。

@table @asis
@c @item A
@item 状態A
@c The difference is showing the A version.  The @kbd{a} command always
@c produces this state; the mode line indicates it with @samp{A}.
この相違箇所はA版の内容である。
@kbd{a}コマンドは必ずこの状態にする。
モード行には@samp{A}と表示される。

@c @item B
@item 状態B
@c The difference is showing the B version.  The @kbd{b} command always
@c produces this state; the mode line indicates it with @samp{B}.
この相違箇所はB版の内容である。
@kbd{b}コマンドは必ずこの状態にする。
モード行には@samp{B}と表示される。

@c @item default-A
@c @itemx default-B
@item デフォルトA
@itemx デフォルトB
@c The difference is showing the A or the B state by default, because you
@c haven't made a choice.  All differences start in the default-A state
@c (and thus the merge buffer is a copy of the A buffer), except those for
@c which one alternative is ``preferred'' (see below).
まだ決心していないので、『デフォルト』で、
相違箇所は状態A(A版の内容)か状態B(B版の内容)である。
どちらかの選択肢が『優先される』(下記参照)場合を除いて、
相違箇所はすべてデフォルトAで始まる
(つまり、併合バッファの内容はAバッファのコピー)。

@c When you select a difference, its state changes from default-A or
@c default-B to plain A or B.  Thus, the selected difference never has
@c state default-A or default-B, and these states are never displayed in
@c the mode line.
相違箇所を選択すると、その状態は、デフォルトAやデフォルトBから
状態Aや状態Bに遷移する。
つまり、一度でも選択した相違箇所は、
デフォルトAやデフォルトBの状態であることはなく、
これらの状態はけっしてモード行には表示されない。

@c The command @kbd{d a} chooses default-A as the default state, and @kbd{d
@c b} chooses default-B.  This chosen default applies to all differences
@c which you haven't ever selected and for which no alternative is preferred.
@c If you are moving through the merge sequentially, the differences you
@c haven't selected are those following the selected one.  Thus, while
@c moving sequentially, you can effectively make the A version the default
@c for some sections of the merge buffer and the B version the default for
@c others by using @kbd{d a} and @kbd{d b} between sections.
デフォルトの状態として、
コマンド@kbd{d a}はデフォルトAを選び、
@kbd{d b}デフォルトBを選ぶ。
これらのコマンドで選んだデフォルトの状態は、
一度も選択してなく、かつ、どちらの版も優先されない相違箇所に適用される。
併合作業を先頭から順に行っている場合、
最後に選択した相違箇所に続く相違箇所群が一度も選択されていないものである。
したがって、先頭から順に進めるのであれば、
@kbd{d a}と@kbd{d b}を使い分けて、
併合バッファのある部分ではA版をデフォルトとし、
別の部分ではB版をデフォルトとすることができる。

@c @item prefer-A
@c @itemx prefer-B
@item 優先A
@itemx 優先B
@c The difference is showing the A or B state because it is
@c @dfn{preferred}.  This means that you haven't made an explicit choice,
@c but one alternative seems likely to be right because the other
@c alternative agrees with the common ancestor.  Thus, where the A buffer
@c agrees with the common ancestor, the B version is preferred, because
@c chances are it is the one that was actually changed.
どちらかが@dfn{優先され}ているので、
相違箇所は状態A(A版の内容)か状態B(B版の内容)である。
つまり、明示的にはまだ選択していないが、当該箇所では、
一方の版が共通の祖先に一致するため、
他方の版のほうが正しく思われるのである。
したがって、Aバッファが共通の祖先と一致する箇所では、
実際に変更されたほうが正しいものである可能性があるので、
B版が優先される。

@c These two states are displayed in the mode line as @samp{A*} and @samp{B*}.
これらの2つの状態は、モード行では@samp{A*}や@samp{B*}と表示される。

@c @item combined
@item 混合状態
@c The difference is showing a combination of the A and B states, as a
@c result of the @kbd{x c} or @kbd{x C} commands.
@kbd{x c}や@kbd{x C}コマンドの結果、
相違箇所は、状態A(A版の内容)と状態B(B版の内容)の混合状態になっている。

@c Once a difference is in this state, the @kbd{a} and @kbd{b} commands
@c don't do anything to it unless you give them a numeric argument.
相違箇所がいったんこの状態になると、
コマンド@kbd{a}や@kbd{b}に数引数を指定しない限り、何もしない。

@c The mode line displays this state as @samp{comb}.
この状態は、モード行では@samp{comb}と表示される。
@end table

@node Merge Commands, Exiting Emerge, State of Difference, Emerge
@c @subsection Merge Commands
@subsection 併合コマンド

@c   Here are the Merge commands for Fast mode; in Edit mode, precede them
@c with @kbd{C-c C-c}:
ここでは、高速モードの併合操作コマンドを示します。
編集モードでは、これらのコマンドのまえに@kbd{C-c C-c}を付けます。

@table @kbd
@item p
@c Select the previous difference.
まえの相違箇所を選択する。

@item n
@c Select the next difference.
つぎの相違箇所を選択する。

@item a
@c Choose the A version of this difference.
この相違箇所をA版にする(状態A)。

@item b
@c Choose the B version of this difference.
この相違箇所をB版にする(状態B)。

@item C-u @var{n} j
@c Select difference number @var{n}.
番号@var{n}の相違箇所を選択する。

@item .
@c Select the difference containing point.  You can use this command in the
@c merge buffer or in the A or B buffer.
ポイントを含む相違箇所を選択する。
このコマンドは、併合バッファ、Aバッファ、Bバッファのいずれでも使える。

@item q
@c Quit---finish the merge.
終了する。
併合作業を完了。

@item C-]
@c Abort---exit merging and do not save the output.
アボートする。
併合作業をやめ、併合結果も保存しない。

@item f
@c Go into Fast mode.  (In Edit mode, this is actually @kbd{C-c C-c f}.)
高速モードに移行する。
(編集モードでは、実際には@kbd{C-c C-c f}コマンド。)

@item e
@c Go into Edit mode.
編集モードに移行する。

@item l
@c Recenter (like @kbd{C-l}) all three windows.
3つのウィンドウすべてを(@kbd{C-l}のように)再表示する。

@item - 
@c Specify part of a prefix numeric argument.
数引数の一部を指定する。

@item @var{digit}
@c Also specify part of a prefix numeric argument.
これも、数引数の一部を指定する。

@item d a
@c Choose the A version as the default from here down in
@c the merge buffer.
併合バッファのこれ以降では、A版を選ぶ(デフォルトA)。

@item d b
@c Choose the B version as the default from here down in
@c the merge buffer.
併合バッファのこれ以降では、B版を選ぶ(デフォルトB)。

@item c a
@c Copy the A version of this difference into the kill ring.
この相違箇所のA版のテキストをキルリングにコピーする。

@item c b
@c Copy the B version of this difference into the kill ring.
この相違箇所のB版のテキストをキルリングにコピーする。

@item i a
@c Insert the A version of this difference at point.
この相違箇所のA版のテキストをポイント位置に挿入する。

@item i b
@c Insert the B version of this difference at point.
この相違箇所のB版のテキストをポイント位置に挿入する。

@item m
@c Put point and mark around the difference.
相違箇所の周りにポイントとマークを設定する。

@item ^
@c Scroll all three windows down (like @kbd{M-v}).
3つのウィンドウすべてを(@kbd{M-v}のように)下にスクロールする。

@item v
@c Scroll all three windows up (like @kbd{C-v}).
3つのウィンドウすべてを(@kbd{C-v}のように)上にスクロールする。

@item <
@c Scroll all three windows left (like @kbd{C-x <}).
3つのウィンドウすべてを(@kbd{C-x <}のように)左にスクロールする。

@item >
@c Scroll all three windows right (like @kbd{C-x >}).
3つのウィンドウすべてを(@kbd{C-x >}のように)右にスクロールする。

@item |
@c Reset horizontal scroll on all three windows.
3つのウィンドウすべてで、水平方向のスクロール分をリセットする。

@item x 1
@c Shrink the merge window to one line.  (Use @kbd{C-u l} to restore it
@c to full size.)
併合バッファを表示しているウィンドウの高さを1行に縮小する。
(フルサイズに戻すには@kbd{C-u l}を使う。)

@item x c
@c Combine the two versions of this difference (@pxref{Combining in
@c Emerge}).
この相違箇所の2つの版を混合する(@pxref{Combining in Emerge})。 

@item x f
@c Show the names of the files/buffers Emerge is operating on, in a Help
@c window.  (Use @kbd{C-u l} to restore windows.)
emergeで作業しているファイル/バッファの名前を、
ヘルプ用ウィンドウに表示する。
(ウィンドウをもとの状態に戻すには@kbd{C-u l}を使う。)

@item x j
@c Join this difference with the following one.
@c (@kbd{C-u x j} joins this difference with the previous one.)
この相違箇所を、つぎの相違箇所と結合する。
(@kbd{C-u x j}では、まえの相違箇所と結合する。)

@item x s
@c Split this difference into two differences.  Before you use this
@c command, position point in each of the three buffers at the place where
@c you want to split the difference.
この相違箇所を2つに分割する。
このコマンドを使うまえに、3つのバッファそれぞれで、
相違箇所を分割したい位置にポイントを移動しておく。

@item x t
@c Trim identical lines off the top and bottom of the difference.
@c Such lines occur when the A and B versions are
@c identical but differ from the ancestor version.
相違箇所の先頭や末尾にある同じ行を取り去る。
このような行が現れるのは、
A版とB版は一致しているが、共通の祖先とは一致しない場合。
@end table

@node Exiting Emerge, Combining in Emerge, Merge Commands, Emerge
@c @subsection Exiting Emerge
@subsection emergeの終了

@c   The @kbd{q} command (@code{emerge-quit}) finishes the merge, storing
@c the results into the output file if you specified one.  It restores the
@c A and B buffers to their proper contents, or kills them if they were
@c created by Emerge and you haven't changed them.  It also disables the
@c Emerge commands in the merge buffer, since executing them later could
@c damage the contents of the various buffers.
@kbd{q}コマンド(@code{emerge-quit})は、併合を終了し、
出力ファイルを指定してあれば、そこに結果を保存します。
AバッファとBバッファは正しい内容に復元されますが、
emergeがAバッファとBバッファを作成して、かつ、編集されていなければ、
それらをキルします。
さらに、併合バッファでのemergeコマンドを使用禁止にします。
というのは、これ以降に併合コマンドを実行すると
さまざまなバッファが悪影響を受ける可能性があるからです。

@c   @kbd{C-]} aborts the merge.  This means exiting without writing the
@c output file.  If you didn't specify an output file, then there is no
@c real difference between aborting and finishing the merge.
@kbd{C-]}は、併合作業をアボートします。
つまり、出力ファイルに書き出さずに終ります。
出力ファイルを指定していなければ、併合作業をアボートしようが終了しようが、
何の違いもありません。

@c   If the Emerge command was called from another Lisp program, then its
@c return value is @code{t} for successful completion, or @code{nil} if you
@c abort.
他のLispプログラムからemergeコマンドが呼び出された場合、
正しく終了すると@code{t}、アボートしたときは@code{nil}が返されます。

@node Combining in Emerge, Fine Points of Emerge, Exiting Emerge, Emerge
@c @subsection Combining the Two Versions
@subsection 2つの版の混合

@c   Sometimes you want to keep @emph{both} alternatives for a particular
@c difference.  To do this, use @kbd{x c}, which edits the merge buffer
@c like this:
相違箇所によっては、@emph{両方}の版を残したいこともあるでしょう。
そのような場合には、@kbd{x c}を使います。
すると、併合バッファはつぎのようになります。

@example
@group
#ifdef NEW
@var{version from A buffer}
#else /* not NEW */
@var{version from B buffer}
#endif /* not NEW */
@end group
@end example

@noindent
@vindex emerge-combine-versions-template
@c While this example shows C preprocessor conditionals delimiting the two
@c alternative versions, you can specify the strings to use by setting
@c the variable @code{emerge-combine-versions-template} to a string of your
@c choice.  In the string, @samp{%a} says where to put version A, and
@c @samp{%b} says where to put version B.  The default setting, which
@c produces the results shown above, looks like this:
この例では、2つの版をCのプリプロセッサの条件節で分けていますが、
変数@code{emerge-combine-versions-template}に好みの文字列を設定すれば、
このコマンドで使用する文字列を指定できます。
この文字列内では、A版のテキストを置く箇所には@samp{%a}を、
B版のを置く箇所には@samp{%b}を指定します。
上に示した結果を生じるデフォルトの設定はつぎのとおりです。

@example
@group
"#ifdef NEW\n%a#else /* not NEW */\n%b#endif /* not NEW */\n"
@end group
@end example

@node Fine Points of Emerge,  , Combining in Emerge, Emerge
@c @subsection Fine Points of Emerge
@subsection 細かな注意点

@c   During the merge, you mustn't try to edit the A and B buffers yourself.
@c Emerge modifies them temporarily, but ultimately puts them back the way
@c they were.
併合作業中には、AバッファやBバッファを勝手に編集してはいけません。
emergeは一時的にこれらのバッファの内容を変更しますが、
最終的にはもとの状態に戻します。

@c   You can have any number of merges going at once---just don't use any one
@c buffer as input to more than one merge at once, since the temporary
@c changes made in these buffers would get in each other's way.
複数の併合処理を同時に進めることもできますが、
別の併合処理の入力に同じバッファを使用してはいけません。
というのは、一時的にせよ、互いに異なる複数の変更が
1つのバッファに加えられてしまうからです。

@c   Starting Emerge can take a long time because it needs to compare the
@c files fully.  Emacs can't do anything else until @code{diff} finishes.
@c Perhaps in the future someone will change Emerge to do the comparison in
@c the background when the input files are large---then you could keep on
@c doing other things with Emacs until Emerge is ready to accept
@c commands.
入力ファイル全体を比較する必要があるため、
emergeの開始にはしばらく時間がかかる場合もあります。
また、@code{diff}コマンドが完了するまで、emergeは何もできません。
たぶん、そのうち誰かがemergeを変更して、
入力ファイルが大きいときにはバックグラウンドで比較を行うようにするでしょう。
そうすれば、emergeがコマンドを受け付けるようになるまで、
Emacsで他の作業を続けられます。

@vindex emerge-startup-hook
@c   After setting up the merge, Emerge runs the hook
@c @code{emerge-startup-hook} (@pxref{Hooks}).
フック@code{emerge-startup-hook}(@pxref{Hooks})が、併合処理の設定の最後
に実行されます。

@node C Modes, Fortran, Emerge, Programs
@c @section C and Related Modes
@section Cモードと関連するモード
@c @cindex C mode
@c @cindex Java mode
@c @cindex Pike mode
@c @cindex IDL mode
@c @cindex CORBA IDL mode
@c @cindex Objective C mode
@c @cindex C++ mode
@c @cindex mode, Java
@c @cindex mode, C
@c @cindex mode, Objective C
@c @cindex mode, CORBA IDL
@c @cindex mode, Pike
@cindex Cモード
@cindex Javaモード
@cindex Pikeモード
@cindex IDLモード
@cindex CORBA IDLモード
@cindex Objective Cモード
@cindex C++モード
@cindex モード、Java
@cindex モード、C
@cindex モード、Objective C
@cindex モード、CORBA IDL
@cindex モード、Pike

@c   This section describes special features available in C, C++,
@c Objective-C, Java, CORBA IDL, and Pike modes.  When we say ``C mode and
@c related modes,'' those are the modes we mean.
本節では、C、C++、Objective-C、Java、CORBA IDL、
Pike用の各モードで利用可能な特別な機能について述べます。
『Cモードと関連するモード』と書いたときには、
これらのモードを意味します。

@menu
* Motion in C::
* Electric C::
* Hungry Delete::
* Other C Commands::
* Comments in C::
@end menu

@node Motion in C, Electric C, , C Modes
@c @subsection C Mode Motion Commands
@subsection Cモードの移動コマンド

@c   This section describes commands for moving point, in C mode and
@c related modes.
本節では、Cモードとその関連モードでポイントを移動する
コマンドについて述べます。

@table @code
@item C-c C-u
@c @kindex C-c C-u @r{(C mode)}
@kindex C-c C-u @r{(Cモード)}
@findex c-up-conditional
@c Move point back to the containing preprocessor conditional, leaving the
@c mark behind.  A prefix argument acts as a repeat count.  With a negative
@c argument, move point forward to the end of the containing
@c preprocessor conditional.  When going backwards, @code{#elif} is treated
@c like @code{#else} followed by @code{#if}.  When going forwards,
@c @code{#elif} is ignored.@refill
マークをポイント位置に設定し、
ポイントを含むプリプロセッサの条件節の先頭に後向きにポイントを戻す。
数引数は反復回数として働く。
負の引数を指定すると、条件節の末尾に前向きにポイントを移動する。
後向きに戻る場合、
@code{#elif}は、@code{#if}が続く@code{#else}のように扱われる。
前向きに進む場合、@code{#elif}は無視される
@footnote{【訳注】@code{#elif}のところで止まってしまう。}。

@item C-c C-p
@c @kindex C-c C-p @r{(C mode)}
@kindex C-c C-p @r{(Cモード)}
@findex c-backward-conditional
@c Move point back over a preprocessor conditional, leaving the mark
@c behind.  A prefix argument acts as a repeat count.  With a negative
@c argument, move forward.
マークをポイント位置に設定し、
プリプロセッサの条件節を横断して後向きにポイントを移動する。
数引数は反復回数として働く。
負の引数を指定すると、前向きに移動する。

@item C-c C-n
@c @kindex C-c C-n @r{(C mode)}
@kindex C-c C-n @r{(Cモード)}
@findex c-forward-conditional
@c Move point forward across a preprocessor conditional, leaving the mark
@c behind.  A prefix argument acts as a repeat count.  With a negative
@c argument, move backward.
マークをポイント位置に設定し、
プリプロセッサの条件節を横断して前向きにポイントを移動する。
数引数は反復回数として働く。
負の引数を指定すると、後向きに移動する。

@item M-a
@kindex ESC a
@findex c-beginning-of-statement
@c Move point to the beginning of the innermost C statement
@c (@code{c-beginning-of-statement}).  If point is already at the beginning
@c of a statement, move to the beginning of the preceding statement.  With
@c prefix argument @var{n}, move back @var{n} @minus{} 1 statements.
もっとも内側のCの文の先頭にポイントを移動する
(@code{c-beginning-of-statement})。
すでに文の先頭にポイントがある場合、直前の文の先頭に移動する。
数引数@var{n}を指定すると、@var{n}@minus{}1だけまえの文に移動する。

@c If point is within a string or comment, or next to a comment (only
@c whitespace between them), this command moves by sentences instead of
@c statements.
ポイントが、文字列やコメントの内側、あるいは、
コメントのうしろ(コメントのあいだに白文字がある場合のみ)にある場合、
Cの文ではなく自然言語の文単位で移動する。

@c When called from a program, this function takes three optional
@c arguments: the numeric prefix argument, a buffer position limit
@c (don't move back before that place), and a flag that controls whether
@c to do sentence motion when inside of a comment.
プログラムから呼ばれるときには、この関数は、3つの引数、つまり、
反復回数、(これよりも後向きには戻らない)移動限界、
ポイントがコメントの内側にある場合に自然言語の文単位の移動をするかどうか、
を取るが、これらは省略できる。

@item M-e
@kindex ESC e
@findex c-end-of-statement
@c Move point to the end of the innermost C statement; like @kbd{M-a}
@c except that it moves in the other direction (@code{c-end-of-statement}).
もっとも内側のCの文の末尾にポイントを移動する。
@kbd{M-a}と同じだが、移動方向が逆(@code{c-end-of-statement})。

@item M-x c-backward-into-nomenclature
@findex c-backward-into-nomenclature
@c Move point backward to beginning of a C++ nomenclature section or word.
@c With prefix argument @var{n}, move @var{n} times.  If @var{n} is
@c negative, move forward.  C++ nomenclature means a symbol name in the
@c style of NamingSymbolsWithMixedCaseAndNoUnderlines; each capital letter
@c begins a section or word.
C++の命名語法の部分や単語の先頭に後向きにポイントを移動する。
数引数@var{n}を指定すると、@var{n}回移動する。
@var{n}が負ならば、前向きに移動する。
C++の命名語法とは、
NamingSymbolsWithMixedCaseAndNoUnderlinesのような形のシンボル名のこと
(つまり、大文字で始めた単語を連結したもの)。
各大文字が部分や単語の先頭となる。

@c In the GNU project, we recommend using underscores to separate words
@c within an identifier in C or C++, rather than using case distinctions.
GNUプロジェクトでは、
CやC++の識別子は、大文字小文字で区別するのではなく、
単語を下線で区切ることを推奨する。

@item M-x c-forward-into-nomenclature
@findex c-forward-into-nomenclature
@c Move point forward to end of a C++ nomenclature section or word.
@c With prefix argument @var{n}, move @var{n} times.
C++の命名語法の部分や単語の末尾に前向きにポイントを移動する。
数引数@var{n}を指定すると、@var{n}回移動する。
@end table

@node Electric C, Hungry Delete, Motion in C, C Modes
@c @subsection Electric C Characters
@subsection エレクトリックC文字

@c   In C mode and related modes, certain printing characters are
@c ``electric''---in addition to inserting themselves, they also reindent
@c the current line and may insert newlines.  This feature is controlled by
@c the variable @code{c-auto-newline}.  The ``electric'' characters are
@c @kbd{@{}, @kbd{@}}, @kbd{:}, @kbd{#}, @kbd{;}, @kbd{,}, @kbd{<},
@c @kbd{>}, @kbd{/}, @kbd{*}, @kbd{(}, and @kbd{)}.
Cモードとその関連モードでは、ある種の印字文字は『エレクトリック』です。
つまり、その文字自身を挿入することに加えて、
現在行を字下げし直したり、改行も挿入することさえあります。
この機能は、変数@code{c-auto-newline}で制御されます。
『エレクトリック』文字は、@kbd{@{}、@kbd{@}}、@kbd{:}、@kbd{#}、
@kbd{;}、@kbd{,}、@kbd{<}、@kbd{>}、@kbd{/}、@kbd{*}、@kbd{(}、@kbd{)}です。

@c   Electric characters insert newlines only when the @dfn{auto-newline}
@c feature is enabled (indicated by @samp{/a} in the mode line after the
@c mode name).  This feature is controlled by the variable
@c @code{c-auto-newline}.  You can turn this feature on or off with the
@c command @kbd{C-c C-a}:
@dfn{自動改行}(auto-newline)機能がオン
(モード行のモード名のあとに@samp{/a}と表示される)の場合に限り、
エレクトリック文字は改行を挿入します。
この機能は、変数@code{c-auto-newline}で制御されます。
コマンド@kbd{C-c C-a}でこの機能をオン/オフできます。

@table @kbd
@item C-c C-a
@c @kindex C-c C-a @r{(C mode)}
@kindex C-c C-a @r{(Cモード)}
@findex c-toggle-auto-state
@c Toggle the auto-newline feature (@code{c-toggle-auto-state}).  With a
@c prefix argument, this command turns the auto-newline feature on if the
@c argument is positive, and off if it is negative.
自動改行機能をオン/オフする(@code{c-toggle-auto-state})。
数引数を指定した場合、正ならば自動改行機能をオンにし、
負ならばオフにする。
@end table

@c   The colon character is electric because that is appropriate for a
@c single colon.  But when you want to insert a double colon in C++, the
@c electric behavior of colon is inconvenient.  You can insert a double
@c colon with no reindentation or newlines by typing @kbd{C-c :}:
コロン@kbd{:}はエレクトリックです。
なぜなら、単独のコロンの入力の解釈としてはそれが適切だからです。
しかし、C++で2つの連続するコロンを挿入する場合、
コロンのエレクトリックな動作は不便です。
@kbd{C-c :}と打てば、字下げも改行の挿入も行わずにコロンを2つ挿入できます。

@table @kbd
@item C-c :
@c @kindex C-c : @r{(C mode)}
@kindex C-c : @r{(Cモード)}
@findex c-scope-operator
@c Insert a double colon scope operator at point, without reindenting the
@c line or adding any newlines (@code{c-scope-operator}).
行の字下げも改行の挿入もせずに、
スコープ演算子を表すコロン2つをポイント位置に挿入する
(@code{c-scope-operator})。
@end table

@c   The electric @kbd{#} key reindents the line if it appears to be the
@c beginning of a preprocessor directive.  This happens when the value of
@c @code{c-electric-pound-behavior} is @code{(alignleft)}.  You can turn
@c this feature off by setting @code{c-electric-pound-behavior} to
@c @code{nil}.
エレクトリックキー@kbd{#}は、
プリプロセッサ指令の始まりと思われる位置では、行を字下げし直します。
変数@code{c-electric-pound-behavior}の値が@code{(alignleft)}のときには、
このようになります。
この機能をオフにするには、
@code{c-electric-pound-behavior}に@code{nil}を設定します。

@c    The variable @code{c-hanging-braces-alist} controls the insertion of
@c newlines before and after inserted braces.  It is an association list
@c with elements of the following form: @code{(@var{syntactic-symbol}
@c . @var{nl-list})}.  Most of the syntactic symbols that appear in
@c @code{c-offsets-alist} are meaningful here as well.
変数@code{c-hanging-braces-alist}は、
挿入された中括弧の前/後への改行の挿入を制御します。
これは、@code{(@var{syntactic-symbol} . @var{nl-list})}の形の要素
から成る連想リストです。
@code{c-offsets-alist}に現れるほとんどの構文シンボルは、
ここでも意味を持ちます。

@c    The list @var{nl-list} may contain either of the symbols
@c @code{before} or @code{after}, or both; or it may be @code{nil}.  When a
@c brace is inserted, the syntactic context it defines is looked up in
@c @code{c-hanging-braces-alist}; if it is found, the @var{nl-list} is used
@c to determine where newlines are inserted: either before the brace,
@c after, or both.  If not found, the default is to insert a newline both
@c before and after braces.
リスト@var{nl-list}は、シンボル@code{before}か@code{after}のいずれか、
あるいはその両方、もしくは@code{nil}を含みます。
中括弧が挿入されるときには、その中括弧が定義する構文上の文脈を
@code{c-hanging-braces-alist}から探します。
みつかれば、@var{nl-list}を使って
中括弧の前/後/前後のどこに改行を挿入するか決定します。
みつからなければ、デフォルトとして中括弧の前後に改行を挿入します。

@c    The variable @code{c-hanging-colons-alist} controls the insertion of
@c newlines before and after inserted colons.  It is an association list
@c with elements of the following form: @code{(@var{syntactic-symbol}
@c . @var{nl-list})}.  The list @var{nl-list} may contain either of the
@c symbols @code{before} or @code{after}, or both; or it may be @code{nil}.
変数@code{c-hanging-colons-alist}は、
挿入されたコロンの前/後への改行の挿入を制御します。
これは、@code{(@var{syntactic-symbol} . @var{nl-list})}の形の要素
から成る連想リストです。
リスト@var{nl-list}は、シンボル@code{before}か@code{after}のいずれか、
あるいはその両方、もしくは@code{nil}を含みます。

@c    When a colon is inserted, the syntactic symbol it defines is looked
@c up in this list, and if found, the @var{nl-list} is used to determine
@c where newlines are inserted: either before the brace, after, or both.
@c If the syntactic symbol is not found in this list, no newlines are
@c inserted.
コロンが挿入されるときには、そのコロンが定義する構文シンボルを
この連想リストから探します。
みつかれば、@var{nl-list}を使って
コロンの前/後のどこに改行を挿入するか決定します。
みつからなければ、改行を挿入しません。

@c    Electric characters can also delete newlines automatically when the
@c auto-newline feature is enabled.  This feature makes auto-newline more
@c acceptable, by deleting the newlines in the most common cases where you
@c do not want them.  Emacs can recognize several cases in which deleting a
@c newline might be desirable; by setting the variable
@c @code{c-cleanup-list}, you can specify @emph{which} of these cases that
@c should happen.  The variable's value is a list of symbols, each
@c describing one case for possible deletion of a newline.  Here are the
@c meaningful symbols, and their meanings:
自動改行機能がオンのときには、エレクトリック文字は自動的に改行を削除します。
この機能により、
改行が不要だと思われるもっとも一般的な場面で改行を削除するので、
自動改行機能をユーザーにより受け入れやすくしています。
Emacsは改行を削除することが望ましいいくつかの場面を認識できますが、
変数@code{c-cleanup-list}を設定すれば、@emph{どの}場面で行うか指定できます。
この変数の値はシンボルのリストです。
各要素は、改行を削除してよい場面を1つ指定します。
以下に指定できるシンボルとその意味を示します。

@table @code
@item brace-catch-brace
@c Clean up @samp{@} catch (@var{condition}) @{} constructs by placing the
@c entire construct on a single line.  The clean-up occurs when you type
@c the @samp{@{}, if there is nothing between the braces aside from
@c @code{catch} and @var{condition}.
@samp{@} catch (@var{condition}) @{}の構造全体を1行に再配置する。
@code{catch}や@var{condition}以外に中括弧のあいだになにもないときに
@samp{@{}を打つと再配置する。

@item brace-else-brace
@c Clean up @samp{@} else @{} constructs by placing the entire construct on
@c a single line.  The clean-up occurs when you type the @samp{@{} after
@c the @code{else}, but only if there is nothing but white space between
@c the braces and the @code{else}.
@samp{@} else @{}の構造全体を1行に再配置する。
@code{else}に続けて@samp{@{}を打ったときに再配置するが、
中括弧と@code{else}のあいだに空白以外の文字がない場合に限る。

@item brace-elseif-brace
@c Clean up @samp{@} else if (@dots{}) @{} constructs by placing the entire
@c construct on a single line.  The clean-up occurs when you type the
@c @samp{@{}, if there is nothing but white space between the @samp{@}} and
@c @samp{@{} aside from the keywords and the @code{if}-condition.
@samp{@} else if (@dots{}) @{}の構造全体を1行に配置する。
@samp{@{}を打ったときに再配置するが、
キーワードと@code{if}の条件式を除いて、
@samp{@}}と@samp{@{}のあいだに空白以外の文字がない場合に限る。

@item empty-defun-braces
@c Clean up empty defun braces by placing the braces on the same
@c line.  Clean-up occurs when you type the closing brace.
空の関数定義の中括弧、@samp{@{}と@samp{@}}を同じ行に再配置する。
閉じ中括弧@samp{@}}を打ったときに再配置する。

@item defun-close-semi
@c Clean up the semicolon after a @code{struct} or similar type
@c declaration, by placing the semicolon on the same line as the closing
@c brace.  Clean-up occurs when you type the semicolon.
@code{struct}や同様の型宣言のあとのセミコロンを閉じ中括弧と同じ行に再配置する。
セミコロンを打ったときに再配置する。

@item list-close-comma
@c Clean up commas following braces in array and aggregate
@c initializers.  Clean-up occurs when you type the comma.
配列/合成体の初期化式の中の閉じ中括弧とそれに続くコンマを同じ行に再配置する。
コンマを打ったときに再配置する。

@item scope-operator
@c Clean up double colons which may designate a C++ scope operator, by
@c placing the colons together.  Clean-up occurs when you type the second
@c colon, but only when the two colons are separated by nothing but
@c whitespace.
C++のスコープ演算子を表している可能性がある2つのコロンを一緒にする。
2つめのコロンを打ったときに一緒にするが、
コロンのあいだに白文字以外の文字がない場合に限る。
@end table

@node Hungry Delete, Other C Commands, Electric C, C Modes
@c @subsection Hungry Delete Feature in C
@subsection Cの欲張りな削除機能

@c   When the @dfn{hungry-delete} feature is enabled (indicated by
@c @samp{/h} or @samp{/ah} in the mode line after the mode name), a single
@c @key{DEL} command deletes all preceding whitespace, not just one space.
@c To turn this feature on or off, use @kbd{C-c C-d}:
@dfn{欲張りな削除}機能をオン
(モード行のモード名のあとに@samp{/h}か@samp{/ah}で表示される)にすると、
1つの@key{DEL}コマンドで、直前の空白1つだけでなく、白文字すべてを削除します。
この機能をオン/オフにするには、@kbd{C-c C-d}を使います。

@table @kbd
@item C-c C-d
@c @kindex C-c C-d @r{(C mode)}
@kindex C-c C-d @r{(Cモード)}
@findex c-toggle-hungry-state
@c Toggle the hungry-delete feature (@code{c-toggle-hungry-state}).  With a
@c prefix argument, this command turns the hungry-delete feature on if the
@c argument is positive, and off if it is negative.
欲張り削除機能(@code{c-toggle-hungry-state})をオン/オフする。
数引数を指定した場合、正ならば欲張り削除機能をオンにし、
負ならばオフにする。

@item C-c C-t
@c @kindex C-c C-t @r{(C mode)}
@kindex C-c C-t @r{(Cモード)}
@findex c-toggle-auto-hungry-state
@c Toggle the auto-newline and hungry-delete features, both at once
@c (@code{c-toggle-auto-hungry-state}).
自動改行機能と欲張り削除機能を同時にオン/オフする 
(@code{c-toggle-auto-hungry-state})。
@end table

@vindex c-hungry-delete-key
@c    The variable @code{c-hungry-delete-key} controls whether the
@c hungry-delete feature is enabled.
変数@code{c-hungry-delete-key}は、
欲張り削除機能がオンかオフかを制御します。

@node Other C Commands, Comments in C, Hungry Delete, C Modes
@c @subsection Other Commands for C Mode
@subsection Cモードのその他のコマンド

@table @kbd
@item C-M-h
@findex c-mark-function
@c @kindex C-M-h @r{(C mode)}
@kindex C-M-h @r{(Cモード)}
@c Put mark at the end of a function definition, and put point at the
@c beginning (@code{c-mark-function}).
関数定義の末尾にマークを設定し、先頭にポイントを置く
(@code{c-mark-function})。

@item M-q
@c @kindex M-q @r{(C mode)}
@kindex M-q @r{(Cモード)}
@findex c-fill-paragraph
@c Fill a paragraph, handling C and C++ comments (@code{c-fill-paragraph}).
@c If any part of the current line is a comment or within a comment, this
@c command fills the comment or the paragraph of it that point is in,
@c preserving the comment indentation and comment delimiters.
CやC++のコメントを考慮して、段落を詰め込む
(@code{c-fill-paragraph})。
現在行にコメントがあったり、現在行がコメントの内側なら、
コメントの字下げとコメント区切りを保存したまま、
ポイント位置のコメントや段落を詰め込む。

@item C-c C-e
@c @cindex macro expansion in C
@c @cindex expansion of C macros
@cindex Cのマクロ展開
@cindex 展開、Cのマクロ
@findex c-macro-expand
@c @kindex C-c C-e @r{(C mode)}
@kindex C-c C-e @r{(Cモード)}
@c Run the C preprocessor on the text in the region, and show the result,
@c which includes the expansion of all the macro calls
@c (@code{c-macro-expand}).  The buffer text before the region is also
@c included in preprocessing, for the sake of macros defined there, but the
@c output from this part isn't shown.
リージョン内のテキストに対してCプリプロセッサを実行し、
マクロ呼び出しを展開した結果を表示する(@code{c-macro-expand})。
リージョンのまえにあるテキストにマクロ定義があることもあるので、
それらもプリプロセッサに渡されるが、その部分の出力は表示しない。

@c When you are debugging C code that uses macros, sometimes it is hard to
@c figure out precisely how the macros expand.  With this command, you
@c don't have to figure it out; you can see the expansions.
マクロを用いたCのコードをデバッグするとき、
どのようにマクロが展開されるか正確に理解するのが難しいことがある。
このコマンドを使えば、マクロ展開のことを考える必要はない。
展開結果を目にすることができる。

@item C-c C-\
@findex c-backslash-region
@c @kindex C-c C-\ @r{(C mode)}
@kindex C-c C-\ @r{(Cモード)}
@c Insert or align @samp{\} characters at the ends of the lines of the
@c region (@code{c-backslash-region}).  This is useful after writing or
@c editing a C macro definition.
リージョン内の行末に@samp{\}文字を挿入したり、
行末の@samp{\}の位置揃えを行う(@code{c-backslash-region})。
Cのマクロ定義を書いたり編集したあとに便利なコマンド。

@c If a line already ends in @samp{\}, this command adjusts the amount of
@c whitespace before it.  Otherwise, it inserts a new @samp{\}.  However,
@c the last line in the region is treated specially; no @samp{\} is
@c inserted on that line, and any @samp{\} there is deleted.
行末がすでに@samp{\}で終っているなら、そのまえに置く白文字の個数を調整する。
そうでなければ、新たに@samp{\}を挿入する。
ただし、リージョン内の最後の行は特別扱いする。
その行に@samp{\}を挿入することはなく、また、@samp{\}がある場合には削除する。

@item M-x cpp-highlight-buffer
@c @cindex preprocessor highlighting
@cindex プリプロセッサ強調表示
@findex cpp-highlight-buffer
@c Highlight parts of the text according to its preprocessor conditionals.
@c This command displays another buffer named @samp{*CPP Edit*}, which
@c serves as a graphic menu for selecting how to display particular kinds
@c of conditionals and their contents.  After changing various settings,
@c click on @samp{[A]pply these settings} (or go to that buffer and type
@c @kbd{a}) to rehighlight the C mode buffer accordingly.
プリプロセッサ指令の条件節に従って、テキストの一部を強調表示する。
このコマンドは@samp{*CPP Edit*}という名前のバッファを表示する。
このバッファは、特定のプリプロセッサ条件とその内容をどのように表示するかを
選択するグラフィックメニュー。
さまざま設定を変更したあとで、@samp{[A]pply these settings}をクリックする
(あるいは、そのバッファへ移動して@kbd{a}と打つ)と、
設定に応じてCモードのバッファを強調表示し直す。

@item C-c C-s
@findex c-show-syntactic-information
@c @kindex C-c C-s @r{(C mode)}
@kindex C-c C-s @r{(Cモード)}
@c Display the syntactic information about the current source line
@c (@code{c-show-syntactic-information}).  This is the information that
@c directs how the line is indented.
現在のソース行に関する構文上の情報を表示する
(@code{c-show-syntactic-information})。
この情報は行の字下げを指示する。
@end table

@node Comments in C,  , Other C Commands, C Modes
@c @subsection Comments in C Modes
@subsection Cモードのコメント

@c    C mode and related modes use a number of variables for controlling
@c comment format.
Cモードとその関連モードでは、
コメントの整形にいくつかの変数を使います。

@table @code
@item c-comment-only-line-offset
@vindex c-comment-only-line-offset
@c Extra offset for line which contains only the start of a comment.  It
@c can be either an integer or a cons cell of the form
@c @code{(@var{non-anchored-offset} . @var{anchored-offset})}, where
@c @var{non-anchored-offset} is the amount of offset given to
@c non-column-zero anchored comment-only lines, and @var{anchored-offset}
@c is the amount of offset to give column-zero anchored comment-only lines.
@c Just an integer as value is equivalent to @code{(@var{val} . 0)}.
コメント開始部分だけを含んだ行に与える余分のオフセット。
この変数の値は整数、あるいは
@code{(@var{non-anchored-offset} . @var{anchored-offset})}の形の
コンスセルのどちらでもかまわない。
ここで、@var{non-anchored-offset}は、
1桁目以降から始まるコメントに与えるオフセット。
@var{anchored-offset}は、0桁目から始まるコメントに与えるオフセット。
整数値だけの場合は、@code{(@var{val} . 0)}と等価。

@item c-comment-start-regexp
@vindex c-comment-start-regexp
@c This buffer-local variable specifies how to recognize the start of a comment.
コメント開始の識別方法を指定するバッファにローカルな変数。

@item c-hanging-comment-ender-p
@vindex c-hanging-comment-ender-p
@c If this variable is @code{nil}, @code{c-fill-paragraph} leaves the
@c comment terminator of a block comment on a line by itself.  The default
@c value is @code{t}, which puts the comment-end delimiter @samp{*/} at the
@c end of the last line of the comment text.
この変数が@code{nil}であると、@code{c-fill-paragraph}は、
ブロックコメントのコメント終了区切りだけの行を作る。
デフォルト値は@code{t}で、
コメント終了区切り@samp{*/}をコメントの最後の行の末尾に置く。

@item c-hanging-comment-starter-p
@vindex c-hanging-comment-starter-p
@c If this variable is @code{nil}, @code{c-fill-paragraph} leaves the
@c starting delimiter of a block comment on a line by itself.  The default
@c value is @code{t}, which puts the comment-start delimiter @samp{/*} at
@c the beginning of the first line of the comment text.
この変数が@code{nil}であると、@code{c-fill-paragraph}は、
ブロックコメントのコメント開始区切りだけの行を作る。
デフォルト値は@code{t}で、
コメント開始区切り@samp{/*}をコメントの最初の行の先頭に置く。
@end table

@node Fortran, Asm Mode, C Modes, Programs
@c @section Fortran Mode
@section Fortranモード
@c @cindex Fortran mode
@c @cindex mode, Fortran
@cindex Fortranモード
@cindex モード、Fortran

@c   Fortran mode provides special motion commands for Fortran statements and
@c subprograms, and indentation commands that understand Fortran conventions
@c of nesting, line numbers and continuation statements.  Fortran mode has
@c its own Auto Fill mode that breaks long lines into proper Fortran
@c continuation lines.
Fortranモードには、Fortranの文と副プログラム向けの特別な移動コマンド、
Fortranの入れ子、行番号と継続文の約束事に従う字下げコマンドがあります。
Fortranモードには、長い行を適切なFortranの継続行に分ける
専用の自動詰め込み(fortran-auto-fill)モードがあります。

@c   Special commands for comments are provided because Fortran comments
@c are unlike those of other languages.  Built-in abbrevs optionally save
@c typing when you insert Fortran keywords.
Fortranのコメントは他の言語のコメントとは異なっているので、
コメントに対する特別なコマンドもあります。
Fortranのキーワードを入力するときの打鍵量を減らせる、
組み込みの略語もあります。

@findex fortran-mode
@c   Use @kbd{M-x fortran-mode} to switch to this major mode.  This command
@c runs the hook @code{fortran-mode-hook} (@pxref{Hooks}).
Fortran用のメジャーモードに切り替えるには、@kbd{M-x fortran-mode}を使います。
このコマンドは、フック@code{fortran-mode-hook}を実行します(@pxref{Hooks})。

@menu
* Motion: Fortran Motion.	 Moving point by statements or subprograms.
* Indent: Fortran Indent.	 Indentation commands for Fortran.
* Comments: Fortran Comments.	 Inserting and aligning comments.
* Autofill: Fortran Autofill.	 Auto fill minor mode for Fortran.
* Columns: Fortran Columns.	 Measuring columns for valid Fortran.
* Abbrev: Fortran Abbrev.	 Built-in abbrevs for Fortran keywords.
* Misc: Fortran Misc.            Other Fortran mode features.
@end menu

@node Fortran Motion, Fortran Indent, , Fortran
@c @subsection Motion Commands
@subsection 移動コマンド

@c   Fortran mode provides special commands to move by subprograms (functions
@c and subroutines) and by statements.  There is also a command to put the
@c region around one subprogram, convenient for killing it or moving it.
Fortran モードには、副プログラム(関数やサブルーチン)や文を単位とて
移動するための特別なコマンドがあります。
また、副プログラムを囲むリージョンを設定するコマンドもあり、
副プログラムをキルしたり移動したりするのに便利です。

@c @kindex C-M-a @r{(Fortran mode)}
@c @kindex C-M-e @r{(Fortran mode)}
@c @kindex C-M-h @r{(Fortran mode)}
@c @kindex C-c C-p @r{(Fortran mode)}
@c @kindex C-c C-n @r{(Fortran mode)}
@kindex C-M-a @r{(Fortranモード)}
@kindex C-M-e @r{(Fortranモード)}
@kindex C-M-h @r{(Fortranモード)}
@kindex C-c C-p @r{(Fortranモード)}
@kindex C-c C-n @r{(Fortranモード)}
@findex beginning-of-fortran-subprogram
@findex end-of-fortran-subprogram
@findex mark-fortran-subprogram
@findex fortran-previous-statement
@findex fortran-next-statement

@table @kbd
@item C-M-a
@c Move to beginning of subprogram
@c (@code{beginning-of-fortran-subprogram}).
副プログラムの先頭に移動する(@code{beginning-of-fortran-subprogram})。
@item C-M-e
@c Move to end of subprogram (@code{end-of-fortran-subprogram}).
副プログラムの末尾に移動する(@code{end-of-fortran-subprogram})。
@item C-M-h
@c Put point at beginning of subprogram and mark at end
@c (@code{mark-fortran-subprogram}).
副プログラムの先頭にポイントを置き、末尾にマークを設定する
(@code{mark-fortran-subprogram})。
@item C-c C-n
@c Move to beginning of current or next statement
@c (@code{fortran-next-statement}).
現在の文かつぎの文の先頭に移動する(@code{fortran-next-statement})。
@item C-c C-p
@c Move to beginning of current or previous statement
@c (@code{fortran-previous-statement}).
現在の文かまえの文の先頭に移動する
(@code{fortran-previous-statement})。
@end table

@node Fortran Indent, Fortran Comments, Fortran Motion, Fortran
@c @subsection Fortran Indentation
@subsection Fortranの字下げ

@c   Special commands and features are needed for indenting Fortran code in
@c order to make sure various syntactic entities (line numbers, comment line
@c indicators and continuation line flags) appear in the columns that are
@c required for standard Fortran.
Fortranのコードでは、構文上の各種要素(行番号、コメント行指示子、
継続マーク)は標準Fortranが要求する桁に現れるようにしなくてはいけないので、
字下げに関する特別なコマンドと機能が必要です。

@menu
* Commands: ForIndent Commands.  Commands for indenting Fortran.
* Contline: ForIndent Cont.      How continuation lines indent.
* 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.
@end menu

@node ForIndent Commands, ForIndent Cont, , Fortran Indent
@c @subsubsection Fortran Indentation Commands
@subsubsection Fortranの字下げコマンド

@table @kbd
@item @key{TAB}
@c Indent the current line (@code{fortran-indent-line}).
現在行を字下げする(@code{fortran-indent-line})。
@item C-j
@c Indent the current and start a new indented line
@c (@code{fortran-indent-new-line}).
現在行を字下げしてから、字下げした新たな行を始める
(@code{fortran-indent-new-line})。
@item C-M-j
@c Break the current line and set up a continuation line.
ポイント位置で現在行を分割し、継続行を設定する。
@item M-^
@c Join this line to the previous line.
現在行と直前の行を繋げる。
@item C-M-q
@c Indent all the lines of the subprogram point is in
@c (@code{fortran-indent-subprogram}).
ポイントを含む副プログラムの行をすべて字下げする
(@code{fortran-indent-subprogram})。
@end table

@findex fortran-indent-line
@c   Fortran mode redefines @key{TAB} to reindent the current line for
@c Fortran (@code{fortran-indent-line}).  This command indents line numbers
@c and continuation markers to their required columns, and independently
@c indents the body of the statement based on its nesting in the program.
Fortranモードでは、Fortranの行を字下げするように@key{TAB}を再定義します
(@code{fortran-indent-line})。
このコマンドは、行番号と継続マークを要求される桁位置に字下げしたうえ、
それとは独立にプログラム中の入れ子に基づいて文本体を字下げします。

@c @kindex C-j @r{(Fortran mode)}
@kindex C-j @r{(Fortranモード)}
@findex fortran-indent-new-line
@c   The key @kbd{C-j} runs the command @code{fortran-indent-new-line},
@c which reindents the current line then makes and indents a new line.
@c This command is useful to reindent the closing statement of @samp{do}
@c loops and other blocks before starting a new line.
キー@kbd{C-j}は@code{fortran-indent-new-line}を実行します。
これは、現在行を字下げしてから、新たな行を作成して字下げします。
新たな行を始めるまえに、@samp{do}ループやその他のブロックを
閉じる文を字下げし直すのに便利です。

@c @kindex C-M-q @r{(Fortran mode)}
@kindex C-M-q @r{(Fortranモード)}
@findex fortran-indent-subprogram
@c   The key @kbd{C-M-q} runs @code{fortran-indent-subprogram}, a command
@c to reindent all the lines of the Fortran subprogram (function or
@c subroutine) containing point.
キー@kbd{C-M-q}は、ポイントを含むFortranの副プログラム
(関数やサブルーチン)の行すべてを字下げする
コマンド@code{fortran-indent-subprogram}を実行します。

@c @kindex C-M-j @r{(Fortran mode)}
@kindex C-M-j @r{(Fortranモード)}
@findex fortran-split-line
@c   The key @kbd{C-M-j} runs @code{fortran-split-line}, which splits
@c a line in the appropriate fashion for Fortran.  In a non-comment line,
@c the second half becomes a continuation line and is indented
@c accordingly.  In a comment line, both halves become separate comment
@c lines.
キー@kbd{C-M-j}は、適切な方法でFortranの行を分割するコマンド
@code{fortran-split-line}を実行します。
コメント行でなければ、後半部を継続行にし、それに応じて字下げします。
コメント行ならば、前後半部分とも独立したコメント行になります。

@c @kindex M-^ @r{(Fortran mode)}
@kindex M-^ @r{(Fortranモード)}
@findex fortran-join-line
@c   @kbd{M-^} runs the command @code{fortran-join-line}, which is more or
@c less the inverse of @code{fortran-split-line}.  It joins the current
@c line to the previous line in a suitable way for Fortran code.
@kbd{M-^}は、@code{fortran-split-line}の逆操作を行う
コマンド@code{fortran-join-line}を実行します。
現在行と直前の行を、Fortranコードとして適切に繋げます。

@node ForIndent Cont, ForIndent Num, ForIndent Commands, Fortran Indent
@c @subsubsection Continuation Lines
@subsubsection 継続行
@c @cindex Fortran continuation lines
@cindex Fortranの継続行

@vindex fortran-continuation-string
@c   Most modern Fortran compilers allow two ways of writing continuation
@c lines.  If the first non-space character on a line is in column 5, then
@c that line is a continuation of the previous line.  We call this
@c @dfn{fixed format}.  (In GNU Emacs we always count columns from 0.)  The
@c variable @code{fortran-continuation-string} specifies what character to
@c put on column 5.  A line that starts with a tab character followed by
@c any digit except @samp{0} is also a continuation line.  We call this
@c style of continuation @dfn{tab format}.
近代的なほとんどのFortranコンパイラには、
継続行の記述方法が2つ用意されています。
ある行の空白でない最初の文字が5桁目にあれば、先行する行の継続行です。
このスタイルを@dfn{固定フォーマット}と呼びます。
(GNU Emacsでは、桁位置はつねに0から数える。)
変数@code{fortran-continuation-string}は、5桁目に置く文字を指定します。
タブ文字で始まり@samp{0}以外の数字が続く行も継続行です。
このスタイルを@dfn{タブフォーマット}と呼びます。

@c @vindex indent-tabs-mode @r{(Fortran mode)}
@vindex indent-tabs-mode @r{(Fortranモード)}
@c   Fortran mode can make either style of continuation line, but you
@c must specify which one you prefer.  The value of the variable
@c @code{indent-tabs-mode} controls the choice: @code{nil} for fixed
@c format, and non-@code{nil} for tab format.  You can tell which style
@c is presently in effect by the presence or absence of the string
@c @samp{Tab} in the mode line.
Fortranモードではどちらのスタイルの継続行も利用できますが、
希望するほうを指定する必要があります。
変数@code{indent-tabs-mode}の値で希望を指定します。
@code{nil}ならば固定フォーマット、
@code{nil}以外ならばタブフォーマットになります。
モード行に文字列@samp{Tab}があるかどうかで、
現在使用しているスタイルがわかります。

@c   If the text on a line starts with the conventional Fortran
@c continuation marker @samp{$}, or if it begins with any non-whitespace
@c character in column 5, Fortran mode treats it as a continuation line.
@c When you indent a continuation line with @key{TAB}, it converts the line
@c to the current continuation style.  When you split a Fortran statement
@c with @kbd{C-M-j}, the continuation marker on the newline is created
@c according to the continuation style.
Fortranモードでは、テキストが慣用的なFortranの継続マーク@samp{$}で始まる、
あるいは、
5桁目から白文字以外の文字で始まる場合には、その行を継続行として扱います。
@key{TAB}で継続行を字下げすると、
選択されている継続行のスタイルに変換します。
@kbd{C-M-j}でFortranの文を分割すると、
継続行のスタイルに応じて新たな行には継続マークを付けます。

@c   The setting of continuation style affects several other aspects of
@c editing in Fortran mode.  In fixed format mode, the minimum column
@c number for the body of a statement is 6.  Lines inside of Fortran
@c blocks that are indented to larger column numbers always use only the
@c space character for whitespace.  In tab format mode, the minimum
@c column number for the statement body is 8, and the whitespace before
@c column 8 must always consist of one tab character.
継続行のスタイルは、Fortranモードでの編集に関わる
その他の側面にも影響します。
固定フォーマットでは、文本体を置く最小桁位置は6になります。
Fortranのブロックの内側にある行を7桁目以降に字下げするときには、
白文字には空白文字を使います。
一方、タブフォーマットでは、文本体を置く最小桁位置は8で、
8桁目よりまえの白文字はつねにタブ文字です。

@vindex fortran-tab-mode-default
@vindex fortran-analyze-depth
@c   When you enter Fortran mode for an existing file, it tries to deduce the
@c proper continuation style automatically from the file contents.  The first
@c line that begins with either a tab character or six spaces determines the
@c choice.  The variable @code{fortran-analyze-depth} specifies how many lines
@c to consider (at the beginning of the file); if none of those lines
@c indicates a style, then the variable @code{fortran-tab-mode-default}
@c specifies the style.  If it is @code{nil}, that specifies fixed format, and
@c non-@code{nil} specifies tab format.
既存のファイルに対してFortranモードに入ると、
その内容から自動的に適切な継続行のスタイルを推測しようとします。
タブ文字か空白6個で始まる最初の行でスタイルを判断します。
変数@code{fortran-analyze-depth}で、
(ファイルの先頭から)何行分をスタイル判断に使用するか指定します。
この範囲内にスタイルを示すような行がみつからなければ、
変数@code{fortran-tab-mode-default}がスタイルを指定します。
@code{nil}なら固定フォーマット、@code{nil}以外ならタブフォーマットです。

@node ForIndent Num, ForIndent Conv, ForIndent Cont, Fortran Indent
@c @subsubsection Line Numbers
@subsubsection 行番号

@c   If a number is the first non-whitespace in the line, Fortran
@c indentation assumes it is a line number and moves it to columns 0
@c through 4.  (Columns always count from 0 in GNU Emacs.)
ある行の白文字以外の最初の文字が数字であれば、
Fortranの字下げではそれを行番号とみなして0桁目から4桁目のあいだに移動します。
(GNU Emacsでは、桁位置はつねに0から始まる。)

@vindex fortran-line-number-indent
@c   Line numbers of four digits or less are normally indented one space.
@c The variable @code{fortran-line-number-indent} controls this; it
@c specifies the maximum indentation a line number can have.  Line numbers
@c are indented to right-justify them to end in column 4 unless that would
@c require more than this maximum indentation.  The default value of the
@c variable is 1.
通常、4桁以下の行番号は空白1個で字下げします。
変数@code{fortran-line-number-indent}でこの字下げ幅を制御します。
この変数の値は、行番号の最大字下げ幅を表します。
最大字下げ幅まで字下げできなくなると、
行番号の最後の桁が4桁目になるように右揃えで字下げします。
この変数のデフォルト値は1です。

@vindex fortran-electric-line-number
@c   Simply inserting a line number is enough to indent it according to
@c these rules.  As each digit is inserted, the indentation is recomputed.
@c To turn off this feature, set the variable
@c @code{fortran-electric-line-number} to @code{nil}.  Then inserting line
@c numbers is like inserting anything else.
これらの規則に従って行番号を字下げするには、
行番号を挿入するだけで十分です。
行番号の各桁が挿入されるたびに、字下げ幅を再計算します。
この機能をオフにするには、
変数@code{fortran-electric-line-number}に@code{nil}を設定します。
こうすると、行番号の挿入はその他の文字の挿入と同様に行われます。

@node ForIndent Conv, ForIndent Vars, ForIndent Num, Fortran Indent
@c @subsubsection Syntactic Conventions
@subsubsection 構文上の規約

@c   Fortran mode assumes that you follow certain conventions that simplify
@c the task of understanding a Fortran program well enough to indent it
@c properly:
Fortranモードでは、適切な字下げをするためのFortranプログラムの解釈を
簡単にするために、以下の規約に従っているものと仮定します。

@itemize @bullet
@item
@c Two nested @samp{do} loops never share a @samp{continue} statement.
2つの入れ子になった@samp{do}ループは、
けっして@samp{continue}文を共有しない。

@item
@c Fortran keywords such as @samp{if}, @samp{else}, @samp{then}, @samp{do}
@c and others are written without embedded whitespace or line breaks.
@samp{if}、@samp{else}、@samp{then}、@samp{do}といった
Fortranのキーワードは、あいだに空白があったり、途中で行分けされない。

@c Fortran compilers generally ignore whitespace outside of string
@c constants, but Fortran mode does not recognize these keywords if they
@c are not contiguous.  Constructs such as @samp{else if} or @samp{end do}
@c are acceptable, but the second word should be on the same line as the
@c first and not on a continuation line.
一般にFortranコンパイラは文字列定数の外側にある空白を無視するが、
Fortranモードは途中に空白が入っているキーワードを認識しない。
@samp{else if}や@samp{end do}のような書き方は許されるが、
2つの単語を同じ行に置いた場合に限る。
継続行に分かれていると認識しない。
@end itemize

@noindent
@c If you fail to follow these conventions, the indentation commands may
@c indent some lines unaesthetically.  However, a correct Fortran program
@c retains its meaning when reindented even if the conventions are not
@c followed.
以上の規約に従っていない場合には、行を美しく字下げできないこともあります。
しかしながら、たとえ規約に従っていなくても、
正しいFortranプログラムであれば字下げによって意味が変わることはありません。

@node ForIndent Vars,  , ForIndent Conv, Fortran Indent
@c @subsubsection Variables for Fortran Indentation
@subsubsection Fortranの字下げのための変数

@vindex fortran-do-indent
@vindex fortran-if-indent
@vindex fortran-structure-indent
@vindex fortran-continuation-indent
@vindex fortran-check-all-num@dots{}
@vindex fortran-minimum-statement-indent@dots{}
@c   Several additional variables control how Fortran indentation works:
Fortranの字下げ動作に影響する変数がいくつかあります。

@table @code
@item fortran-do-indent
@c Extra indentation within each level of @samp{do} statement (default 3).
@samp{do}文の各レベルごとに追加する字下げ幅(デフォルトは3)。

@item fortran-if-indent
@c Extra indentation within each level of @samp{if} statement (default 3).
@c This value is also used for extra indentation within each level of the
@c Fortran 90 @samp{where} statement.
@samp{if}文の各レベルごとに追加する字下げ幅(デフォルトは3)。
この値は、Fortran 90の@samp{where}文の字下げにも使われる。

@item fortran-structure-indent
@c Extra indentation within each level of @samp{structure}, @samp{union}, or
@c @samp{map} statements (default 3).
@samp{structure}、@samp{union}、@samp{map}の各文の各レベルごとに
追加する字下げ幅(デフォルトは3)。

@item fortran-continuation-indent
@c Extra indentation for bodies of continuation lines (default 5).
継続行の文本体に追加する字下げ幅(デフォルトは5)。

@item fortran-check-all-num-for-matching-do
@c If this is @code{nil}, indentation assumes that each @samp{do} statement
@c ends on a @samp{continue} statement.  Therefore, when computing
@c indentation for a statement other than @samp{continue}, it can save time
@c by not checking for a @samp{do} statement ending there.  If this is
@c non-@code{nil}, indenting any numbered statement must check for a
@c @samp{do} that ends there.  The default is @code{nil}.
この変数が@code{nil}なら、字下げ処理では、
@samp{do}文は@samp{continue}文で終っていると仮定する。
こうすると、@samp{continue}以外の文の字下げを計算するときに、
当該文が@samp{do}文を終えるかどうか検査しなくてよいので、
時間を節約できる。
この変数が@code{nil}以外であれば、
行番号が付いた文の字下げを計算するときには、
当該文が@samp{do}文を終えるかどうか検査する必要がある。
デフォルト値は@code{nil}。

@item fortran-blink-matching-if
@c If this is @code{t}, indenting an @samp{endif} statement moves the
@c cursor momentarily to the matching @samp{if} statement to show where it
@c is.  The default is @code{nil}.
この変数が@code{t}なら、@samp{endif}文の字下げを行うときに、
対応する@samp{if}文を示すために一時的にカーソルを移動する。
デフォルト値は@code{nil}。

@item fortran-minimum-statement-indent-fixed
@c Minimum indentation for fortran statements when using fixed format
@c continuation line style.  Statement bodies are never indented less than
@c this much.  The default is 6.
固定フォーマットの継続行スタイルを採用したときの、文に対する最小字下げ幅。
文本体の字下げ幅がこの値より小さくなることはない。
デフォルト値は6。

@item fortran-minimum-statement-indent-tab
@c Minimum indentation for fortran statements for tab format continuation line
@c style.  Statement bodies are never indented less than this much.  The
@c default is 8.
タブフォーマットの継続行スタイルを採用したときの、文に対する最小字下げ幅。
文本体の字下げ幅がこの値より小さくなることはない。
デフォルト値は8。
@end table

@node Fortran Comments, Fortran Autofill, Fortran Indent, Fortran
@c @subsection Fortran Comments
@subsection Fortranのコメント

@c   The usual Emacs comment commands assume that a comment can follow a line
@c of code.  In Fortran, the standard comment syntax requires an entire line
@c to be just a comment.  Therefore, Fortran mode replaces the standard Emacs
@c comment commands and defines some new variables.
Emacsの通常のコメント用コマンドは、コメントをコードのあとにも置けると仮定します。
Fortranでは、標準的なコメントの構文は、1つの行全体を必要とします。
そのため、Fortranモードでは、
Emacsの通常のコメント用コマンドを置き換え、新たな変数をいくつか定義しています。

@c   Fortran mode can also handle a nonstandard comment syntax where comments
@c start with @samp{!} and can follow other text.  Because only some Fortran
@c compilers accept this syntax, Fortran mode will not insert such comments
@c unless you have said in advance to do so.  To do this, set the variable
@c @code{comment-start} to @samp{"!"} (@pxref{Variables}).
Fortranモードでは、文字@samp{!}で始まり他のテキストのあとにも置ける
非標準的なコメントの構文も扱えます。
しかし、この構文を受け付けるFortranコンパイラは限られるため、
まえもって指定しておかない限り、
Fortranモードは非標準のコメントを使いません。
このスタイルのコメントを使うには、
変数@code{comment-start}に@samp{"!"}を設定します(@pxref{Variables})。

@table @kbd
@item M-;
@c Align comment or insert new comment (@code{fortran-comment-indent}).
コメントの位置を揃えたり、新たなコメントを挿入する
(@code{fortran-indent-comment})。

@item C-x ;
@c Applies to nonstandard @samp{!} comments only.
非標準の@samp{!}コメントだけに作用する。

@item C-c ;
@c Turn all lines of the region into comments, or (with argument) turn them back
@c into real code (@code{fortran-comment-region}).
リージョン内のすべての行をコメントにする。
あるいは、(引数を指定すると)コメントをコードに戻す
(@code{fortran-comment-region})。
@end table

@c   @kbd{M-;} in Fortran mode is redefined as the command
@c @code{fortran-comment-indent}.  Like the usual @kbd{M-;} command, this
@c recognizes any kind of existing comment and aligns its text appropriately;
@c if there is no existing comment, a comment is inserted and aligned.  But
@c inserting and aligning comments are not the same in Fortran mode as in
@c other modes.
Fortranモードの@kbd{M-;}は、
コマンド@code{fortran-indent-comment}に再定義されています。
通常の@kbd{M-;}と同じく、既存のコメントを認識して、
そのテキストの桁位置を揃えます。
コメントがなければ、コメントを挿入して桁位置を揃えます。
しかし、Fortranモードのコメントの挿入と揃え方は、
他のモードと同じではありません。

@c   When a new comment must be inserted, if the current line is blank, a
@c full-line comment is inserted.  On a non-blank line, a nonstandard @samp{!}
@c comment is inserted if you have said you want to use them.  Otherwise a
@c full-line comment is inserted on a new line before the current line.
新たにコメントを挿入する場合、
現在行が空行のときは(1行全体を占める)行コメントを挿入します。
空行でないとき、非標準のコメントを使うように指定してあれば
非標準の@samp{!}コメントを挿入します。
いずれでもないときには、現在行のまえに行コメントを挿入します。

@c   Nonstandard @samp{!} comments are aligned like comments in other
@c languages, but full-line comments are different.  In a standard full-line
@c comment, the comment delimiter itself must always appear in column zero.
@c What can be aligned is the text within the comment.  You can choose from
@c three styles of alignment by setting the variable
@c @code{fortran-comment-indent-style} to one of these values:
非標準の@samp{!}コメントは他の言語のコメントと同じように揃えられますが、
行コメントの場合はようすが異なります。
標準の行コメントでは、コメント区切りはつねに0桁目にある必要があります。
コメント内部のテキストだけを揃えます。
@code{fortran-comment-indent-style}を設定して、
3種類の揃え方を選べます。

@vindex fortran-comment-indent-style
@vindex fortran-comment-line-extra-indent
@table @code
@item fixed
@c Align the text at a fixed column, which is the sum of
@c @code{fortran-comment-line-extra-indent} and the minimum statement
@c indentation.  This is the default.
@code{fortran-comment-line-extra-indent}と文に対する最小字下げ幅を合計し
た桁位置にテキストを揃える。
デフォルトはこれ。

@c The minimum statement indentation is
@c @code{fortran-minimum-statement-indent-fixed} for fixed format
@c continuation line style and @code{fortran-minimum-statement-indent-tab}
@c for tab format style.
文の最小字下げ幅は、
固定フォーマットの継続行スタイルの場合には
@code{fortran-minimum-statement-indent-fixed}の値、
タブフォーマットの場合には@code{fortran-minimum-statement-indent-tab}の値。

@item relative
@c Align the text as if it were a line of code, but with an additional
@c @code{fortran-comment-line-extra-indent} columns of indentation.
コード行であるかのように揃えるが、
@code{fortran-comment-line-extra-indent}だけ余計に桁をずらす。

@item nil
@c Don't move text in full-line comments automatically at all.
行コメントのテキストを勝手に動かさない。
@end table

@vindex fortran-comment-indent-char
@c   In addition, you can specify the character to be used to indent within
@c full-line comments by setting the variable
@c @code{fortran-comment-indent-char} to the single-character string you want
@c to use.
また、行コメントの字下げ文字を変更したければ、
変数@code{fortran-comment-indent-char}に好みの1文字を設定してください。

@vindex comment-line-start
@vindex comment-line-start-skip
@c   Fortran mode introduces two variables @code{comment-line-start} and
@c @code{comment-line-start-skip}, which play for full-line comments the same
@c roles played by @code{comment-start} and @code{comment-start-skip} for
@c ordinary text-following comments.  Normally these are set properly by
@c Fortran mode, so you do not need to change them.
Fortranモードには、@code{comment-line-start}と
@code{comment-line-start-skip}の2つの変数が新たに導入されています。
これらは、コードのあとに置く通常のコメントに対する@code{comment-start}と
@code{comment-start-skip}と同様の役割を、行コメントに対して果たします。
どちらもFortranモードが適切に設定するので、
変更する必要はありません。

@c   The normal Emacs comment command @kbd{C-x ;} has not been redefined.  If
@c you use @samp{!} comments, this command can be used with them.  Otherwise
@c it is useless in Fortran mode.
Emacsの通常のコメント用コマンド@kbd{C-x ;}は、再定義されていません。
このコマンドは@samp{!}コメントを扱えます。
@samp{!}コメントを使っていない場合には、
このコマンドはFortranモードでは役に立ちません。

@c @kindex C-c ; @r{(Fortran mode)}
@kindex C-c ; @r{(Fortranモード)}
@findex fortran-comment-region
@vindex fortran-comment-region
@c   The command @kbd{C-c ;} (@code{fortran-comment-region}) turns all the
@c lines of the region into comments by inserting the string @samp{C$$$} at
@c the front of each one.  With a numeric argument, it turns the region
@c back into live code by deleting @samp{C$$$} from the front of each line
@c in it.  The string used for these comments can be controlled by setting
@c the variable @code{fortran-comment-region}.  Note that here we have an
@c example of a command and a variable with the same name; these two uses
@c of the name never conflict because in Lisp and in Emacs it is always
@c clear from the context which one is meant.
コマンド@kbd{C-c ;}(@code{fortran-comment-region})は、
リージョン内のすべての行の先頭に@samp{C$$$}を挿入して
コメントに変えます。
数引数を指定すると、行の先頭から@samp{C$$$}を削除して、
リージョンを生きたコードに戻します。
これらのコメントに使う文字列は、
変数@code{fortran-comment-region}の設定で制御できます。
ところで、ここではコマンドと変数に同じ名前が使われています。
LispやEmacsにおいては、使用される文脈から
コマンドと変数をつねに区別できるので、
このような名前の使い方が問題を起こすことはありません。

@node Fortran Autofill, Fortran Columns, Fortran Comments, Fortran
@c @subsection Fortran Auto Fill Mode
@subsection Fortran専用自動詰め込み(fortran-auto-fill)モード

@c   Fortran Auto Fill mode is a minor mode which automatically splits
@c Fortran statements as you insert them when they become too wide.
@c Splitting a statement involves making continuation lines using
@c @code{fortran-continuation-string} (@pxref{ForIndent Cont}).  This
@c splitting happens when you type @key{SPC}, @key{RET}, or @key{TAB}, and
@c also in the Fortran indentation commands.
Fortran専用自動詰め込み(fortran-auto-fill)モードは、
挿入したFortranの文が長くなりすぎると自動的に文を分割するマイナモードです。
文を分割するには、
@code{fortran-continuation-string}(@pxref{ForIndent Cont})を用いて
継続行を作ります。
@key{SPC}、@key{RET}、@key{TAB}を打ったときや、
字下げコマンドを使ったときに分割されます。

@findex fortran-auto-fill-mode
@c   @kbd{M-x fortran-auto-fill-mode} turns Fortran Auto Fill mode on if it
@c was off, or off if it was on.  This command works the same as @kbd{M-x
@c auto-fill-mode} does for normal Auto Fill mode (@pxref{Filling}).  A
@c positive numeric argument turns Fortran Auto Fill mode on, and a
@c negative argument turns it off.  You can see when Fortran Auto Fill mode
@c is in effect by the presence of the word @samp{Fill} in the mode line,
@c inside the parentheses.  Fortran Auto Fill mode is a minor mode, turned
@c on or off for each buffer individually.  @xref{Minor Modes}.
@kbd{M-x fortran-auto-fill-mode}は、
Fortran専用自動詰め込み(fortran-auto-fill)モードがオンならばオフにし、
オフならばオンにします。
このコマンドは、通常の自動詰め込み(auto-fill)モード
(@pxref{Filling})である@kbd{M-x auto-fill-mode}が行うのと
同じように働きます。
正の数引数を指定すると、
Fortran専用自動詰め込み(fortran-auto-fill)モードをオンにし、
負であればオフにします。
このモードのオン/オフは、モード行の括弧の中に@samp{Fill}が
あるかどうかで判断できます。
Fortran専用自動詰め込み(fortran-auto-fill)モードはマイナモードなので、
各バッファごとに独立にオン/オフにできます。
@xref{Minor Modes}。

@vindex fortran-break-before-delimiters
@c    Fortran Auto Fill mode breaks lines at spaces or delimiters when the
@c lines get longer than the desired width (the value of @code{fill-column}).
@c The delimiters that Fortran Auto Fill mode may break at are @samp{,},
@c @samp{'}, @samp{+}, @samp{-}, @samp{/}, @samp{*}, @samp{=}, and @samp{)}.
@c The line break comes after the delimiter if the variable
@c @code{fortran-break-before-delimiters} is @code{nil}.  Otherwise (and by
@c default), the break comes before the delimiter.
Fortran専用自動詰め込み(fortran-auto-fill)モードは、
行の長さが規定の幅(@code{fill-column}の値)を越えると、
空白や区切りの位置で行を分割します。
Fortran専用自動詰め込み(fortran-auto-fill)が分割する区切りは、
@samp{,}、@samp{'}、@samp{+}、@samp{-}、@samp{/}、@samp{*}、
@samp{=}、@samp{)}です。
変数@code{fortran-break-before-delimiters}が@code{nil}の場合には、
区切りのうしろで分割します。
それ以外(デフォルトでもある)では、区切りのまえで分割します。

@c   By default, Fortran Auto Fill mode is not enabled.  If you want this
@c feature turned on permanently, add a hook function to
@c @code{fortran-mode-hook} to execute @code{(fortran-auto-fill-mode 1)}.
@c @xref{Hooks}.
デフォルトではFortran専用自動詰め込み(fortran-auto-fill)モードはオフです。
この機能を恒常的に使いたければ、
@code{(fortran-auto-fill-mode 1)}を実行するフック関数を
@code{fortran-mode-hook}に追加してください。
@xref{Hooks}。

@node Fortran Columns, Fortran Abbrev, Fortran Autofill, Fortran
@c @subsection Checking Columns in Fortran
@subsection 桁位置の確認

@table @kbd
@item C-c C-r
@c Display a ``column ruler'' momentarily above the current line
@c (@code{fortran-column-ruler}).
現在行の上にしばらくのあいだ『桁定規』を表示する
(@code{fortran-column-ruler})。
@item C-c C-w
@c Split the current window horizontally temporarily so that it is 72
@c columns wide.  This may help you avoid making lines longer than the
@c 72-character limit that some Fortran compilers impose
@c (@code{fortran-window-create-momentarily}).
現在のウィンドウを一時的に分割して幅を72桁にする。
一部のFortranコンパイラは1行を72文字以内に制限しているので、
このコマンドを使用すれば1行が長くなりすぎることを防げる
(@code{fortran-window-create-momentarily})。
@end table

@c @kindex C-c C-r @r{(Fortran mode)}
@kindex C-c C-r @r{(Fortranモード)}
@findex fortran-column-ruler
@vindex fortran-column-ruler
@c   The command @kbd{C-c C-r} (@code{fortran-column-ruler}) shows a column
@c ruler momentarily above the current line.  The comment ruler is two lines
@c of text that show you the locations of columns with special significance in
@c Fortran programs.  Square brackets show the limits of the columns for line
@c numbers, and curly brackets show the limits of the columns for the
@c statement body.  Column numbers appear above them.
コマンド@kbd{C-c C-r}(@code{fortran-column-ruler})は、
桁定規をしばらくのあいだ、現在行の上に表示します。
桁定規は、Fortranプログラムにおいて特別な意味をもつ桁位置を表す
2行のテキストです。
2行目の角括弧と中括弧で、それぞれ、行番号と文の本体の範囲を表します。
桁番号は(それらの上の)1行目に表示されます。

@c   Note that the column numbers count from zero, as always in GNU Emacs.
@c As a result, the numbers may be one less than those you are familiar
@c with; but the positions they indicate in the line are standard for
@c Fortran.
GNU Emacsでは桁番号をつねに0から数えることに注意してください。
その結果、桁定規に示される桁番号は、
慣れ親しんだものより1だけ小さくなります。
しかし、それらが表す位置はFortranの標準に従ったものです。

@c   The text used to display the column ruler depends on the value of 
@c the variable @code{indent-tabs-mode}.  If @code{indent-tabs-mode} is
@c @code{nil}, then the value of the variable
@c @code{fortran-column-ruler-fixed} is used as the column ruler.
@c Otherwise, the variable @code{fortran-column-ruler-tab} is displayed.
@c By changing these variables, you can change the column ruler display.
桁定規の表示に用いるテキストは、
変数@code{indent-tabs-mode}の値に依存します。
この変数の値が@code{nil}ならば、
変数@code{fortran-column-ruler-fixed}の値を桁定規の表示に使います。
@code{nil}以外であれば、変数
@code{fortran-column-ruler-tab}の内容を表示に使います。
これらの変数の内容を変更すれば、桁定規の表示を変更できます。

@c @kindex C-c C-w @r{(Fortran mode)}
@kindex C-c C-w @r{(Fortranモード)}
@findex fortran-window-create
@c   For even more help, use @kbd{C-c C-w} (@code{fortran-window-create}), a
@c command which splits the current window horizontally, making a window 72
@c columns wide.  By editing in this window you can immediately see when you
@c make a line too wide to be correct Fortran.
さらに桁合わせを支援するために、
@kbd{C-c C-w}(@code{fortran-window-create})は、
現在のウィンドウを幅が72桁になるように横位置で分割します。
このウィンドウで編集すれば、
正しいFortranのプログラムとしては長すぎる行を即座に発見できます。

@node Fortran Abbrev, Fortran Misc, Fortran Columns, Fortran
@c @subsection Fortran Keyword Abbrevs
@subsection Fortranのキーワードの略語

@c   Fortran mode provides many built-in abbrevs for common keywords and
@c declarations.  These are the same sort of abbrev that you can define
@c yourself.  To use them, you must turn on Abbrev mode.  @xref{Abbrevs}.
Fortranモードには、一般的なキーワードや宣言に対する
数多くの組み込み略語があります。
これらは、ユーザー自身が定義できる略語と同じ種類のものです。
それらを使うには、略語(abbrev)モードをオンにします。
@xref{Abbrevs}。

@c   The built-in abbrevs are unusual in one way: they all start with a
@c semicolon.  You cannot normally use semicolon in an abbrev, but Fortran
@c mode makes this possible by changing the syntax of semicolon to ``word
@c constituent.''
組み込み略語は他の略語と1つの点で変わっています。
すべてセミコロンで始まります。
通常は略語にはセミコロンを使えませんが、
Fortranモードでは、セミコロンの構文上の意味を『単語を構成する文字』に
変更することで、これを可能にしています。

@c   For example, one built-in Fortran abbrev is @samp{;c} for
@c @samp{continue}.  If you insert @samp{;c} and then insert a punctuation
@c character such as a space or a newline, the @samp{;c} expands automatically
@c to @samp{continue}, provided Abbrev mode is enabled.@refill
たとえば、@samp{continue}に対する組み込みFortran略語は@samp{;c}です。
略語(abbrev)モードがオンのときに、
@samp{;c}を挿入してから空白や改行といった句読点文字を挿入すると、
@samp{;c}は自動的に@samp{continue}と展開されます。

@c   Type @samp{;?} or @samp{;C-h} to display a list of all the built-in
@c Fortran abbrevs and what they stand for.
組み込みFortran略語とその展開形の一覧を表示するには、
@samp{;?}あるいは@samp{;C-h}と打ちます。

@node Fortran Misc,  , Fortran Abbrev, Fortran
@c @subsection Other Fortran Mode Commands
@subsection Fortranモードのその他のコマンド

@table @kbd
@item C-x n d
@c Narrow to the current Fortran subprogram.
現在のFortranの副プログラムにナロイングする。
@end table

@c @kindex C-x n d @r{(Fortran mode)}
@kindex C-x n d @r{(Fortranモード)}
@findex fortran-narrow-to-subprogram
@c   Fortran mode redefines the key @kbd{C-x n d} to run the command
@c @code{fortran-narrow-to-subprogram}, which is the Fortran analogue
@c of the key's usual definition.  It narrows the buffer to the subprogram
@c containing point.
Fortranモードでは、
キー@kbd{C-x n d}はコマンド@code{fortran-narrow-to-subprogram}を実行するように
再定義しています。
このコマンドは、キーの通常の定義をFrotran風にしたものです。
バッファをポイントを含む副プログラムにナロイングします。

@node Asm Mode,  , Fortran, Programs
@c @section Asm Mode
@section asmモード

@c @cindex Asm mode
@cindex asmモード
@cindex モード、Asm
@c Asm mode is a major mode for editing files of assembler code.  It
@c defines these commands:
asmモードは、アセンブリコードのファイルを編集するためのメジャーモードです。
つぎのコマンドが定義されています。

@table @kbd
@item @key{TAB}
@c @code{tab-to-tab-stop}.
@code{tab-to-tab-stop}。
@item C-j
@c Insert a newline and then indent using @code{tab-to-tab-stop}.
改行を挿入し、@code{tab-to-tab-stop}で字下げする。
@item :
@c Insert a colon and then remove the indentation from before the label
@c preceding colon.  Then do @code{tab-to-tab-stop}.
コロンを挿入し、コロンに先行するラベルのまえの字下げを取り除く。
そして、@code{tab-to-tab-stop}を行う。
@item ;
@c Insert or align a comment.
コメントの挿入/位置揃えを行う。
@end table

@c   The variable @code{asm-comment-char} specifies which character
@c starts comments in assembler syntax.
変数@code{asm-comment-char}は、
アセンブラ構文でコメントを開始する文字を指定します。

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>