@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 Basic, Minibuffer, Exiting, Top
@c @chapter Basic Editing Commands
@chapter 基本編集コマンド

@kindex C-h t
@findex help-with-tutorial
@c   We now give the basics of how to enter text, make corrections, and
@c save the text in a file.  If this material is new to you, you might
@c learn it more easily by running the Emacs learn-by-doing tutorial.  To
@c use the tutorial, run Emacs and type @kbd{Control-h t}
@c (@code{help-with-tutorial}).
テキストの入力、修正、ファイルへの保存といった基本操作について説明します。
これらに接するのが初めてという読者は、
手を動かしながら学ぶチュートリアルを実行したほうが、
もっと簡単に習得できる思います。
チュートリアルを利用するには、
Emacsを起動して@kbd{Control-h t}と打ちます。
@footnote{【訳注】Emacsのインストールの仕方によっては、
きちんと日本語のチュートリアルが表示される。
そうでなければ、
@kbd{M-x set-language-environment @key{RET} Japanese @key{RET}}（あるいは、
@kbd{C-x @key{RET} l Japanese @key{RET}}）と打ってから、
改めて@kbd{Control-h t}と打つ。
日本語以外にもいくつかの言語のチュートリアルがある。}

@c   To clear the screen and redisplay, type @kbd{C-l} (@code{recenter}).
画面をクリアして再表示するには、@kbd{C-l}（@code{recenter}）と打ちます。

@menu

* Inserting Text::      Inserting text by simply typing it.
* Moving Point::        How to move the cursor to the place where you want to
			  change something.
* Erasing::	        Deleting and killing text.
* Undo::	        Undoing recent changes in the text.
* Files: Basic Files.   Visiting, creating, and saving files.
* Help: Basic Help.     Asking what a character does.
* Blank Lines::	        Commands to make or delete blank lines.
* Continuation Lines::  Lines too wide for the screen.
* Position Info::       What page, line, row, or column is point on?
* Arguments::	        Numeric arguments for repeating a command.
* Repeating::           A short-cut for repeating the previous command.
@end menu

@node Inserting Text, Moving Point, , Basic
@c @section Inserting Text
@section テキストを挿入する

@c @cindex insertion
@c @cindex graphic characters
@cindex 挿入
@cindex 図形文字
@c   To insert printing characters into the text you are editing, just type
@c them.  This inserts the characters you type into the buffer at the
@c cursor (that is, at @dfn{point}; @pxref{Point}).  The cursor moves
@c forward, and any text after the cursor moves forward too.  If the text
@c in the buffer is @samp{FOOBAR}, with the cursor before the @samp{B},
@c then if you type @kbd{XX}, you get @samp{FOOXXBAR}, with the cursor
@c still before the @samp{B}.
編集中のテキストに印字文字を挿入するには、
単にその文字を打ちます。
こうすると、打鍵した文字がバッファのカーソル位置
（すなわち@dfn{ポイント}位置。@pxref{Point}）に挿入されます。
カーソルは右（前向き）に移動して、
それにあわせてカーソル以降のすべてのテキストも右（前向き）に移動します。
バッファ内のテキストが@samp{FOOBAR}であって、
カーソルが@samp{B}に重なっているとすると、
@kbd{XX}と打つとカーソルは@samp{B}に重なったままで、
@samp{FOOXXBAR}となります。

@c    To @dfn{delete} text you have just inserted, use @key{DEL}.  @key{DEL}
@c deletes the character @emph{before} the cursor (not the one that the cursor
@c is on top of or under; that is the character @var{after} the cursor).  The
@c cursor and all characters after it move backwards.  Therefore, if you type
@c a printing character and then type @key{DEL}, they cancel out.
挿入したばかりのテキストを@dfn{削除}（delete）するには、
@key{DEL}キーを使います。
@key{DEL}キーは@emph{カーソルのまえ}の文字を削除します
（カーソルが重なっている文字ではない。
その文字はカーソルの@var{うしろ}にある）。
カーソルとカーソル以降のすべてのテキストは左（後向き）に移動します。
つまり、図形文字を1つ打った直後に@key{DEL}を打つと、
挿入を取り消したことになります。

@kindex RET
@c @cindex newline
@cindex 改行
@c    To end a line and start typing a new one, type @key{RET}.  This
@c inserts a newline character in the buffer.  If point is in the middle of
@c a line, @key{RET} splits the line.  Typing @key{DEL} when the cursor is
@c at the beginning of a line deletes the preceding newline, thus joining
@c the line with the preceding line.
行を終えて新たな行を打ち始めるには、@key{RET}を打ちます。
これにより、バッファに改行文字が挿入されます。
ポイントが行の途中にある場合、@key{RET}は行を分割します。
カーソルが行頭にあるときに@key{DEL}を打つと、
直前の改行文字が削除されて直前の行と連結されます。

@c   Emacs can split lines automatically when they become too long, if you
@c turn on a special minor mode called @dfn{Auto Fill} mode.
@c @xref{Filling}, for how to use Auto Fill mode.
@dfn{自動詰め込み}（auto-fill）モードと呼ばれる特別なマイナモードを
オンにしておくと、行が長くなりすぎたときにEmacsが自動的に行を分割します。
自動詰め込み（auto-fill）モードの使い方は、@xref{Filling}。

@c   If you prefer to have text characters replace (overwrite) existing
@c text rather than shove it to the right, you can enable Overwrite mode,
@c a minor mode.  @xref{Minor Modes}.
既存のテキストを右に押しやるのではなく、
テキストを順次置き換える（上書きする）のが好みならば、
マイナモードの1つである上書き（overwrite）モードをオンにします。
@xref{Minor Modes}。

@c @cindex quoting
@cindex クォート
@kindex C-q
@findex quoted-insert
@c   Direct insertion works for printing characters and @key{SPC}, but other
@c characters act as editing commands and do not insert themselves.  If you
@c need to insert a control character or a character whose code is above 200
@c octal, you must @dfn{quote} it by typing the character @kbd{Control-q}
@c (@code{quoted-insert}) first.  (This character's name is normally written
@c @kbd{C-q} for short.)  There are two ways to use @kbd{C-q}:@refill
印字文字と@key{SPC}は直接挿入できますが、
それ以外の文字は編集コマンドとして機能して、それ自体を挿入しません。
コントロール文字や8進で0200を超える文字コードの文字を挿入したい場合には、
まず@kbd{Control-q}（@code{quoted-insert}）と打って、
それらの文字を@dfn{クォート}（quote）
@footnote{【訳注】なんらの解釈もせずに、単なる文字として扱う。}
する必要があります。
（@kbd{Control-q}は、通常、@kbd{C-q}と略す。）
@kbd{C-q}の使い方には、つぎの2つがあります。

@itemize @bullet
@item
@c @kbd{C-q} followed by any non-graphic character (even @kbd{C-g})
@c inserts that character.
@kbd{C-q}に続く非図形文字（@kbd{C-g}でさえも）を挿入する。

@item
@c @kbd{C-q} followed by a sequence of octal digits inserts the character
@c with the specified octal character code.  You can use any number of
@c octal digits; any non-digit terminates the sequence.  If the terminating
@c character is @key{RET}, it serves only to terminate the sequence; any
@c other non-digit is itself used as input after terminating the sequence.
@c (The use of octal sequences is disabled in ordinary non-binary Overwrite
@c mode, to give you a convenient way to insert a digit instead of
@c overwriting with it.)
@kbd{C-q}に続く8進数字列は、8進数字列で指定されるコードの文字を挿入する。
8進数字の桁数はいくつでもかまわず、8進数字以外で数字列は終る。
終端の文字が@key{RET}であれば、単に数字列を終らせるだけ。
それ以外の非数字は、数字列を終らせるだけでなく、
その文字自身も入力として扱われる。
（普通の上書き（overwrite）モードでは、
上書きのかわりに挿入を簡単に行う手段としているため、
この8進数字列は使えない。）
@end itemize

@noindent
@c When multibyte characters are enabled, octal codes 0200 through 0377 are
@c not valid as characters; if you specify a code in this range, @kbd{C-q}
@c assumes that you intend to use some ISO Latin-@var{n} character set, and
@c converts the specified code to the corresponding Emacs character code.
@c @xref{Enabling Multibyte}.  You select @emph{which} ISO Latin character
@c set though your choice of language environment (@pxref{Language
@c Environments}).
マルチバイト文字が使用可ならば、
8進コード0200から0377までは正しい文字ではありません。
この範囲のコードを指定すると、
@kbd{C-q}はISO Latin-@var{n}文字集合の利用を意図しているとみなして、
指定したコードを対応するEmacs文字コードに変換します。
@xref{Enabling Multibyte}。
言語環境の選択（@pxref{Language Environments}）を介して、
ISO Latin文字集合を1つ選びます。

@vindex read-quoted-char-radix
@c To use decimal or hexadecimal instead of octal, set the variable
@c @code{read-quoted-char-radix} to 10 or 16.  If the radix is greater than
@c 10, some letters starting with @kbd{a} serve as part of a character
@c code, just like digits.
8進数のかわりに10進数や16進数を使うには、
変数@code{read-quoted-char-radix}に10や16を設定します。
基数が10を超える場合には、@kbd{a}から始まるいくつかの英字は
文字コードの一部として数字の桁と同じように扱われます。

@c A numeric argument to @kbd{C-q} specifies how many copies of the
@c quoted character should be inserted (@pxref{Arguments}).
@kbd{C-q}に数引数を指定すると、
クォートした文字を何個挿入するかを指定します（@pxref{Arguments}）。

@findex newline
@findex self-insert
@c   Customization information: @key{DEL} in most modes runs the command
@c @code{delete-backward-char}; @key{RET} runs the command @code{newline}, and
@c self-inserting printing characters run the command @code{self-insert},
@c which inserts whatever character was typed to invoke it.  Some major modes
@c rebind @key{DEL} to other commands.
カスタマイズ情報：@code{ }
ほとんどのモードでは、
@key{DEL}はコマンド@code{delete-backward-char}を実行します。
@key{RET}はコマンド@code{newline}を実行します。
自己挿入の図形文字はコマンド@code{self-insert}を実行します。
@code{self-insert}は、これを起動した文字が何であってもその文字を挿入します。
いくつかのメジャーモードでは、
@key{DEL}を別のコマンドにバインドし直しています。

@node Moving Point, Erasing, Inserting Text, Basic
@c @section Changing the Location of Point
@section ポイント位置を移動する

@c @cindex arrow keys
@cindex 矢印キー
@kindex LEFT
@kindex RIGHT
@kindex UP
@kindex DOWN
@c @cindex moving point
@c @cindex movement
@c @cindex cursor motion
@c @cindex moving the cursor
@cindex ポイントの移動
@cindex 移動
@cindex カーソルの移動
@c   To do more than insert characters, you have to know how to move point
@c (@pxref{Point}).  The simplest way to do this is with arrow keys, or by
@c clicking the left mouse button where you want to move to.
文字の挿入以外のことを行うには、ポイント（@pxref{Point}）
の移動方法を知っておく必要があります。
もっとも簡単な方法は、矢印キーを使うか、
移動先の箇所でマウスの左ボタンをクリックします。

@c   There are also control and meta characters for cursor motion.  Some
@c are equivalent to the arrow keys (these date back to the days before
@c terminals had arrow keys, and are usable on terminals which don't have
@c them).  Others do more sophisticated things.
カーソル移動のためのコントロール文字やメタ文字もあります。
一部は矢印キーと同等です
（これらは、矢印キーを備えた端末が現れるまえからあった。
矢印キーがない端末では便利）。
他のものは、こったことをします。

@kindex C-a
@kindex C-e
@kindex C-f
@kindex C-b
@kindex C-n
@kindex C-p
@kindex M->
@kindex M-<
@kindex M-r
@findex beginning-of-line
@findex end-of-line
@findex forward-char
@findex backward-char
@findex next-line
@findex previous-line
@findex beginning-of-buffer
@findex end-of-buffer
@findex goto-char
@findex goto-line
@findex move-to-window-line
@table @kbd
@item C-a
@c Move to the beginning of the line (@code{beginning-of-line}).
行頭に移動する（@code{beginning-of-line}）。
@item C-e
@c Move to the end of the line (@code{end-of-line}).
行末に移動する（@code{end-of-line}）。
@item C-f
@c Move forward one character (@code{forward-char}).
前向き（右）に1文字移動する（@code{forward-char}）。
@item C-b
@c Move backward one character (@code{backward-char}).
後向き（左）に1文字移動する（@code{backward-char}）。
@item M-f
@c Move forward one word (@code{forward-word}).
前向きに1語移動する（@code{forward-word}）。
@item M-b
@c Move backward one word (@code{backward-word}).
後向きに1語移動する（@code{backward-word}）。
@item C-n
@c Move down one line, vertically (@code{next-line}).  This command
@c attempts to keep the horizontal position unchanged, so if you start in
@c the middle of one line, you end in the middle of the next.  When on
@c the last line of text, @kbd{C-n} creates a new line and moves onto it.
垂直に1行下へ移動する（@code{next-line}）。
このコマンドは行内での横方向の位置を保とうとする。
したがって、行の途中で使うと、つぎの行の途中に移動する。
テキストの最終行である場合には、
@kbd{C-n}は新たな行を作り、その行へ移動する。
@item C-p
@c Move up one line, vertically (@code{previous-line}).
垂直に1行上へ移動する（@code{previous-line}）。
@item M-r
@c Move point to left margin, vertically centered in the window
@c (@code{move-to-window-line}).  Text does not move on the screen.
ポイントをウィンドウの縦方向の中央位置で左端に移動する
（@code{move-to-window-line}）。
テキストは画面上を移動しない。

@c A numeric argument says which screen line to place point on.  It counts
@c screen lines down from the top of the window (zero for the top line).  A
@c negative argument counts lines from the bottom (@minus{}1 for the bottom
@c line).
数引数は、画面上の何行目にポイントを移動するかを指定する。
行数は、ウィンドウ上端（0行目）から下向きに数える。
負の引数では、ウィンドウの下端（@minus{}1行）から数える。
@item M-<
@c Move to the top of the buffer (@code{beginning-of-buffer}).  With
@c numeric argument @var{n}, move to @var{n}/10 of the way from the top.
@c @xref{Arguments}, for more information on numeric arguments.@refill
バッファの先頭に移動する（@code{beginning-of-buffer}）。
数引数@var{n}を指定すると、先頭から全体の@var{n}/10の行にポイントを移動する。
数引数の詳細については、@pxref{Arguments}。
@item M->
@c Move to the end of the buffer (@code{end-of-buffer}).
バッファの末尾に移動する（@code{end-of-buffer}）。
@item M-x goto-char
@c Read a number @var{n} and move point to buffer position @var{n}.
@c Position 1 is the beginning of the buffer.
数値@var{n}を読み取り、バッファの@var{n}番目の文字にポイントを移動する。
バッファの先頭が位置1。
@item M-x goto-line
@c Read a number @var{n} and move point to line number @var{n}.  Line 1
@c is the beginning of the buffer.
数値@var{n}を読み取り、@var{n}行目にポイントを移動する。
バッファの先頭が第1行。
@item C-x C-n
@findex set-goal-column
@kindex C-x C-n
@c Use the current column of point as the @dfn{semipermanent goal column} for
@c @kbd{C-n} and @kbd{C-p} (@code{set-goal-column}).  Henceforth, those
@c commands always move to this column in each line moved into, or as
@c close as possible given the contents of the line.  This goal column remains
@c in effect until canceled.
現在ポイントがある桁を@kbd{C-n}や@kbd{C-p}の
@dfn{半恒久的な目標桁}として設定する。
このあと、これらのコマンドは、移動先の各行でこの桁位置に、あるいは、
行の内容によっては可能な限りこの桁に近い位置にポイントを移動する。
この目標桁は取り消すまで有効。
@item C-u C-x C-n
@c Cancel the goal column.  Henceforth, @kbd{C-n} and @kbd{C-p} once
@c again try to stick to a fixed horizontal position, as usual.
目標桁を取り消す。
これ以後、@kbd{C-n}や@kbd{C-p} は、通常のように
横方向の位置を保とうとする。
@end table

@vindex track-eol
@c   If you set the variable @code{track-eol} to a non-@code{nil} value,
@c then @kbd{C-n} and @kbd{C-p} when at the end of the starting line move
@c to the end of another line.  Normally, @code{track-eol} is @code{nil}.
@c @xref{Variables}, for how to set variables such as @code{track-eol}.
変数@code{track-eol}に@code{nil}以外を設定すると、
行末にポイントがある場合の@kbd{C-n}や@kbd{C-p}は、
移動先の行でも行末にポイントを移動します。
通常、@code{track-eol}は@code{nil}です。
@code{track-eol}のような変数の設定方法については、@xref{Variables}。

@vindex next-line-add-newlines
@c   Normally, @kbd{C-n} on the last line of a buffer appends a newline to
@c it.  If the variable @code{next-line-add-newlines} is @code{nil}, then
@c @kbd{C-n} gets an error instead (like @kbd{C-p} on the first line).
通常、バッファの最終行での@kbd{C-n}は、新しい行を追加します。
変数@code{next-line-add-newlines}が@code{nil}である場合、
@kbd{C-n}は新規の行を追加せずに
（先頭行での@kbd{C-p}と同様に）エラーになります。

@node Erasing, Undo, Moving Point, Basic
@c @section Erasing Text
@section テキストの消去

@table @kbd
@item @key{DEL}
@c Delete the character before point (@code{delete-backward-char}).
ポイントの直前の文字を削除する（@code{delete-backward-char}）。
@item C-d
@c Delete the character after point (@code{delete-char}).
ポイントの直後の文字を削除する（@code{delete-char}）。
@item C-k
@c Kill to the end of the line (@code{kill-line}).
行末までをキルする（@code{kill-line}）。
@item M-d
@c Kill forward to the end of the next word (@code{kill-word}).
つぎの語の末尾までを前向きにキルする（@code{kill-word}）。
@item M-@key{DEL}
@c Kill back to the beginning of the previous word
@c (@code{backward-kill-word}).
まえの語の先頭までを後向きにキルする（@code{backward-kill-word}）。
@end table

@c @cindex killing characters and lines
@c @cindex deleting characters and lines
@c @cindex erasing characters and lines
@cindex 文字や行のキル
@cindex 文字や行の削除
@cindex 文字や行の消去
@c   You already know about the @key{DEL} key which deletes the character
@c before point (that is, before the cursor).  Another key, @kbd{Control-d}
@c (@kbd{C-d} for short), deletes the character after point (that is, the
@c character that the cursor is on).  This shifts the rest of the text on
@c the line to the left.  If you type @kbd{C-d} at the end of a line, it
@c joins together that line and the next line.
ポイントの直前（つまり、カーソルの直前）の文字を削除する
@key{DEL}キーについてはすでに知っていますね。
@kbd{Control-d}（@kbd{C-d}と略記）は、ポイントの直後の文字
（つまり、カーソルが重なっている文字）を削除します。
すると、残りのテキストは左に移動します。
行末で@kbd{C-d}を打つと、その行とつぎの行が連結されます。

@c   To erase a larger amount of text, use the @kbd{C-k} key, which kills a
@c line at a time.  If you type @kbd{C-k} at the beginning or middle of a
@c line, it kills all the text up to the end of the line.  If you type
@c @kbd{C-k} at the end of a line, it joins that line and the next line.
大量のテキストを消去するには、@kbd{C-k}を使います。
@kbd{C-k}は1行を一度にキルします。
行頭や行の途中で@kbd{C-k}を打つと、
行末までのすべてのテキストをキルします。
行末で@kbd{C-k}を打つと、その行とつぎの行を連結します。

@c   @xref{Killing}, for more flexible ways of killing text.
より柔軟なテキストのキルについての詳細は、@xref{Killing}。

@node Undo, Basic Files, Erasing, Basic
@c @section Undoing Changes
@section 変更をアンドゥする（もとに戻す）
@c @cindex undo
@c @cindex changes, undoing
@cindex アンドゥ（もとに戻す）
@cindex 変更、もとに戻す

@c   You can undo all the recent changes in the buffer text, up to a
@c certain point.  Each buffer records changes individually, and the undo
@c command always applies to the current buffer.  Usually each editing
@c command makes a separate entry in the undo records, but some commands
@c such as @code{query-replace} make many entries, and very simple commands
@c such as self-inserting characters are often grouped to make undoing less
@c tedious.
バッファのテキストに対する変更は、ある時点まで遡って、
すべてアンドゥ（もとに戻すことが）できます。
各バッファでは個々の変更をそれぞれ記録していて、
アンドゥコマンドは、つねにカレントバッファに作用します。
通常、各編集コマンドはアンドゥ記録に別々の項目を作成しますが、
@code{query-replace}のようなコマンドは一度に多くの項目を作りますし、
自己挿入文字のように非常に単純なコマンドは、
もとに戻すのを単純にするために、まとめられます。

@table @kbd
@item C-x u
@c Undo one batch of changes---usually, one command worth (@code{undo}).
一塊の変更をもとに戻す。
普通、1つのコマンドに相当する（@code{undo}）。
@item C-_
@c The same.
同じ。
@item C-u C-x u
@c Undo one batch of changes in the region.
リージョン内で、一塊の変更をもとに戻す。
@end table

@kindex C-x u
@kindex C-_
@findex undo
@c   The command @kbd{C-x u} or @kbd{C-_} is how you undo.  The first time
@c you give this command, it undoes the last change.  Point moves back to
@c where it was before the command that made the change.
変更をもとに戻すには、コマンド、@kbd{C-x u}や@kbd{C-_}を使います。
始めにこのコマンドを実行すると、直前の変更をもとに戻します。
ポイントは、もとに戻されたコマンドを実行するまえの位置に戻ります。

@c   Consecutive repetitions of @kbd{C-_} or @kbd{C-x u} undo earlier and
@c earlier changes, back to the limit of the undo information available.
@c If all recorded changes have already been undone, the undo command
@c prints an error message and does nothing.
@kbd{C-_}や@kbd{C-x u}を連続して実行すると、
アンドゥ情報の限界に達するまで、
次々に以前の変更をもとに戻していきます。
記録されているすべての変更をもとに戻してしまうと、
アンドゥコマンドはその旨エラーメッセージを表示します。

@c   Any command other than an undo command breaks the sequence of undo
@c commands.  Starting from that moment, the previous undo commands become
@c ordinary changes that you can undo.  Thus, to redo changes you have
@c undone, type @kbd{C-f} or any other command that will harmlessly break
@c the sequence of undoing, then type more undo commands.
アンドゥコマンド以外の他のコマンドを実行すると、
アンドゥコマンドの連続実行系列が断ち切られます。
これ以後、これよりまえのアンドゥコマンドの実行自体が、
もとに戻すことが可能な一般の変更として扱われます。
したがって、もとに戻してしまった変更をやはりそのとおりに
変更しておきたい場合には、
@kbd{C-f}と打つか、あるいは、無害なコマンドを実行して
アンドゥの連続実行系列を断ち切ってから、さらにアンドゥコマンドを打ちます。

@c @cindex selective undo
@cindex 選択的なアンドゥ
@kindex C-u C-x u
@c   Ordinary undo applies to all changes made in the current buffer.  You
@c can also perform @dfn{selective undo}, limited to the current region.
@c To do this, specify the region you want, then run the @code{undo}
@c command with a prefix argument (the value does not matter): @kbd{C-u C-x
@c u} or @kbd{C-u C-_}.  This undoes the most recent change in the region.
@c To undo further changes in the same region, repeat the @code{undo}
@c command (no prefix argument is needed).  In Transient Mark mode, any use
@c of @code{undo} when there is an active region performs selective undo;
@c you do not need a prefix argument.
普通のアンドゥは、カレントバッファにおけるすべての変更に作用します。
カレントリージョン内に制限した@dfn{選択的なアンドゥ}（selective undo）を
行うこともできます。
これには、リージョンを設定してから、数引数（値は関係ない）を指定して
@code{undo}コマンドを、つまり、@kbd{C-u C-x u}や@kbd{C-u C-_}を実行します。
これにより、リージョン内のもっとも最近の変更がもとに戻ります。
同じリージョン内の変更をさらにもとに戻すには、
@code{undo}コマンドを繰り返します（これには数引数は必要ない）。
暫定マーク（transient-mark）モードでは、
リージョンが活性のときに@code{undo}を使うと選択的なアンドゥを行います。
つまり、数引数は必要ありません。

@c   If you notice that a buffer has been modified accidentally, the
@c easiest way to recover is to type @kbd{C-_} repeatedly until the stars
@c disappear from the front of the mode line.  At this time, all the
@c modifications you made have been canceled.  Whenever an undo command
@c makes the stars disappear from the mode line, it means that the buffer
@c contents are the same as they were when the file was last read in or
@c saved.
バッファを誤って変更してしまった場合、
もとに戻すもっとも簡単な方法は、モード行の先頭部分から星印が
消えるまで@kbd{C-_}を繰り返し打つことです。
そうすれば、すべての修正を取り消したことになります。
アンドゥコマンドによりモード行から星印が消えた場合はつねに、
バッファの内容がファイルを訪問したときと同じであるか、
最後に保存したときと同じであることを意味します。

@c   If you do not remember whether you changed the buffer deliberately,
@c type @kbd{C-_} once.  When you see the last change you made undone, you
@c will see whether it was an intentional change.  If it was an accident,
@c leave it undone.  If it was deliberate, redo the change as described
@c above.
意図してバッファを変更したかどうかあやふやなときは、
一度だけ@kbd{C-_}を打ちます。
もとに戻すことで最後の変更箇所がわかりますから、
それが意図した変更かどうか判断できるでしょう。
意図した変更でなければ、もとに戻したままにしておきます。
意図した変更であったなら、上記の方法で変更し直します。

@c   Not all buffers record undo information.  Buffers whose names start with
@c spaces don't; these buffers are used internally by Emacs and its extensions
@c to hold text that users don't normally look at or edit.
すべてのバッファでアンドゥ情報を記録するわけではありません。
空白で始まる名前のバッファでは記録しません。
これらのバッファは、
Emacsやその拡張部分が内部的に使用するもので、
ユーザーが通常見たり編集したりしないテキストを保持しています。

@c   You cannot undo mere cursor motion; only changes in the buffer
@c contents save undo information.  However, some cursor motion commands
@c set the mark, so if you use these commands from time to time, you can
@c move back to the neighborhoods you have moved through by popping the
@c mark ring (@pxref{Mark Ring}).
単なるカーソル移動はアンドゥできません。
バッファの内容を変更したときだけアンドゥ情報が保存されます。
ただし、いくつかのカーソル移動コマンドはマークを設定しますから、
これらのコマンドをときどき使えば、
マークリング（@pxref{Mark Ring}）から取り出しながら、
通ってきたそれぞれの箇所へ戻ることができます。

@vindex undo-limit
@vindex undo-strong-limit
@c @cindex undo limit
@cindex アンドゥの限界
@c   When the undo information for a buffer becomes too large, Emacs
@c discards the oldest undo information from time to time (during garbage
@c collection).  You can specify how much undo information to keep by
@c setting two variables: @code{undo-limit} and @code{undo-strong-limit}.
@c Their values are expressed in units of bytes of space.
バッファに関するアンドゥ情報が大きくなると、
Emacsはもっとも古いアンドゥ情報から順に（ガベッジコレクション中に）
破棄していきます。
保持すべきアンドゥ情報の量を指定するには、
2つの変数@code{undo-limit}と@code{undo-strong-limit}を設定します。
これらの変数の値は、保存領域のバイト数です。

@c   The variable @code{undo-limit} sets a soft limit: Emacs keeps undo
@c data for enough commands to reach this size, and perhaps exceed it, but
@c does not keep data for any earlier commands beyond that.  Its default
@c value is 20000.  The variable @code{undo-strong-limit} sets a stricter
@c limit: the command which pushes the size past this amount is itself
@c forgotten.  Its default value is 30000.
変数@code{undo-limit}は緩い限界（soft limit）を設定します。
Emacsは、このサイズに達するまでのコマンド分のアンドゥデータを保持します。
データ量がこのサイズを超える場合もありますが、
このデータ量を超えるような古いコマンド分のデータは保持しません。
デフォルトは、20000です。
変数@code{undo-strong-limit}は、厳密な限界（stricter limit）を設定します。
この量を超えるデータに対応するコマンドのデータは破棄します。
初期値は30000です。

@c   Regardless of the values of those variables, the most recent change is
@c never discarded, so there is no danger that garbage collection occurring
@c right after an unintentional large change might prevent you from undoing
@c it.
これらの変数の値に関わらず、最新の変更を破棄することはありませんので、
意図しない大きな変更を加えてしまった直後に
ガベッジコレクションが発生しても、
その変更をアンドゥできないというようなことはありません。

@c   The reason the @code{undo} command has two keys, @kbd{C-x u} and
@c @kbd{C-_}, set up to run it is that it is worthy of a single-character
@c key, but on some keyboards it is not obvious how to type @kbd{C-_}.
@c @kbd{C-x u} is an alternative you can type straightforwardly on any
@c terminal.
アンドゥコマンドを実行するキーが@kbd{C-x u}と@kbd{C-_}と2つある理由は、
1文字キーにするほど重要なのですが、どうやって@kbd{C-_}を打つか自明でない
キーボードもあるからです。
@kbd{C-x u}は、どの端末でも素直に打てる代替手段なのです。

@node Basic Files, Basic Help, Undo, Basic
@c @section Files
@section ファイル

@c   The commands described above are sufficient for creating and altering
@c text in an Emacs buffer; the more advanced Emacs commands just make
@c things easier.  But to keep any text permanently you must put it in a
@c @dfn{file}.  Files are named units of text which are stored by the
@c operating system for you to retrieve later by name.  To look at or use
@c the contents of a file in any way, including editing the file with
@c Emacs, you must specify the file name.
Emacsバッファ内でテキストを作成したり変更したりするには、
これまでに説明したコマンドで十分なはずです。
より高度なEmacsコマンドといっても、
これらの操作を容易にするだけです。
しかし、テキストを恒久的なものとするには、
@dfn{ファイル}（file）に保存する必要があります。
ファイルとは、
オペレーティングシステムが保存するために名前を付けたテキストの一塊であり、
あとでその名前で取り出せます。
Emacsでファイルを編集する場合を含めて、
ファイルの内容を眺めたり利用したりするには、
ファイル名を指定する必要があります。

@c   Consider a file named @file{/usr/rms/foo.c}.  In Emacs, to begin editing
@c this file, type
@file{/usr/rms/foo.c}という名前のファイルがあるとしましょう。
このファイルを編集し始めるには、Emacsではつぎのように打ちます。

@example
C-x C-f /usr/rms/foo.c @key{RET}
@end example

@noindent
@c Here the file name is given as an @dfn{argument} to the command @kbd{C-x
@c C-f} (@code{find-file}).  That command uses the @dfn{minibuffer} to
@c read the argument, and you type @key{RET} to terminate the argument
@c (@pxref{Minibuffer}).@refill
ここで、ファイル名は、コマンド@kbd{C-x C-f}（@code{find-file}）に対する
@dfn{引数}（argument）として与えます。
このコマンドは引数を読むために@dfn{ミニバッファ}を使います。
引数の入力を終えるには、@key{RET}を打ちます（@pxref{Minibuffer}）。

@c   Emacs obeys the command by @dfn{visiting} the file: creating a buffer,
@c copying the contents of the file into the buffer, and then displaying
@c the buffer for you to edit.  If you alter the text, you can @dfn{save}
@c the new text in the file by typing @kbd{C-x C-s} (@code{save-buffer}).
@c This makes the changes permanent by copying the altered buffer contents
@c back into the file @file{/usr/rms/foo.c}.  Until you save, the changes
@c exist only inside Emacs, and the file @file{foo.c} is unaltered.
Emacsはコマンドに従い、ファイルを@dfn{訪問}（visiting）します。
つまり、バッファを作成し、ファイルの内容をそのバッファにコピーし、
ユーザーが編集できるようにそのバッファを表示します。
テキストを変更したら、@kbd{C-x C-s}（@code{save-buffer}）と打てば、
新しいテキストをファイルに@dfn{保存}（save）できます。
これにより、バッファの変更した内容を
ファイル@file{/usr/rms/foo.c}にコピーし戻したので、
変更は恒久的になります。
ユーザーが保存するまでは、変更はEmacs内部のみに存在するだけで、
ファイル@file{foo.c}自体は未変更のままです。

@c   To create a file, just visit the file with @kbd{C-x C-f} as if it
@c already existed.  This creates an empty buffer in which you can insert
@c the text you want to put in the file.  The file is actually created when
@c you save this buffer with @kbd{C-x C-s}.
ファイルを作成するには、そのファイルが既存であるかのように、
@kbd{C-x C-f}でファイルを訪問するだけです。
これにより、空のバッファが作られ、
ファイルに収めたいテキストを挿入できるようになります。
@kbd{C-x C-s}でバッファを保存したときに、
ファイルが実際に作成されます。

@c   Of course, there is a lot more to learn about using files.  @xref{Files}.
もちろん、ファイルについてはもっと知っておく必要があります。
@xref{Files}。

@node Basic Help, Blank Lines, Basic Files, Basic
@c @section Help
@section ヘルプ

@c @cindex getting help with keys
@cindex キーのヘルプ表示
@c   If you forget what a key does, you can find out with the Help
@c character, which is @kbd{C-h} (or @key{F1}, which is an alias for
@c @kbd{C-h}).  Type @kbd{C-h k} followed by the key you want to know
@c about; for example, @kbd{C-h k C-n} tells you all about what @kbd{C-n}
@c does.  @kbd{C-h} is a prefix key; @kbd{C-h k} is just one of its
@c subcommands (the command @code{describe-key}).  The other subcommands of
@c @kbd{C-h} provide different kinds of help.  Type @kbd{C-h} twice to get
@c a description of all the help facilities.  @xref{Help}.@refill
キーの機能を忘れてしまった場合には、
ヘルプ文字@kbd{C-h}（あるいは@kbd{C-h}の別名である@key{F1}）を使って、
調べられます。
@kbd{C-h k}と打ってから、調べたいキーを続けて打ちます。
たとえば、@kbd{C-h k C-n}は、@kbd{C-n}が何をするか教えてくれます。
@kbd{C-h}はプレフィックスキーです。
@kbd{C-h k}は、@kbd{C-h}の1つのサブコマンド
（コマンド@code{describe-key}）です。
@kbd{C-h}には他にもサブコマンドがあり、
それぞれ異なる種類のヘルプを表示します。
@kbd{C-h}を2回打てば、ヘルプ機能自体の説明を見ることができます。
@xref{Help}。

@node Blank Lines, Continuation Lines, Basic Help, Basic
@c @section Blank Lines
@section 空行

@c @cindex inserting blank lines
@c @cindex deleting blank lines
@cindex 空行の挿入
@cindex 空行の削除
@c   Here are special commands and techniques for putting in and taking out
@c blank lines.
空行の挿入と削除に関する特別なコマンドや技法を紹介します。

@c widecommands
@table @kbd
@item C-o
@c Insert one or more blank lines after the cursor (@code{open-line}).
カーソルの直後に1行以上の空行を挿入する（@code{open-line}）。
@item C-x C-o
@c Delete all but one of many consecutive blank lines
@c (@code{delete-blank-lines}).
連続する空行を1行だけ残してすべて削除する（@code{delete-blank-lines}）。
@end table

@kindex C-o
@kindex C-x C-o
@c @cindex blank lines
@cindex 空行
@findex open-line
@findex delete-blank-lines
@c   When you want to insert a new line of text before an existing line, you
@c can do it by typing the new line of text, followed by @key{RET}.
@c However, it may be easier to see what you are doing if you first make a
@c blank line and then insert the desired text into it.  This is easy to do
@c using the key @kbd{C-o} (@code{open-line}), which inserts a newline
@c after point but leaves point in front of the newline.  After @kbd{C-o},
@c type the text for the new line.  @kbd{C-o F O O} has the same effect as
@c @w{@kbd{F O O @key{RET}}}, except for the final location of point.
既存の行のまえに新たに1行を挿入するには、
新しい行のテキストを打ってから@key{RET}を打つこともできます。
しかし、まず空行を作ってから、
そこに希望のテキストを挿入するほうが何をしているのかがわかりやすいでしょう。
キー@kbd{C-o}（@code{open-line}）を使えば簡単です。
これはポイントの直後に改行を挿入して、
ポイントは改行の直前に置かれたままとなります。
@kbd{C-o}に続けて、新しい行のテキストを打ちます。
@kbd{C-o F O O}は、ポイントの最終的な位置を除けば、
@w{@kbd{F O O @key{RET}}}と同じ効果を持ちます。

@c   You can make several blank lines by typing @kbd{C-o} several times, or
@c by giving it a numeric argument to tell it how many blank lines to make.
@c @xref{Arguments}, for how.  If you have a fill prefix, then @kbd{C-o}
@c command inserts the fill prefix on the new line, when you use it at the
@c beginning of a line.  @xref{Fill Prefix}.
複数の空行を作るには、@kbd{C-o}を数回打つか、
作りたい空行の個数を指定する数引数を指定します。
数引数の指定方法は、@xref{Arguments}。
詰め込み接頭辞を設定してある場合、
行の先頭で@kbd{C-o}コマンドを使うと、
このコマンドは新しい行に詰め込み接頭辞を挿入します。
@xref{Fill Prefix}。

@c   The easy way to get rid of extra blank lines is with the command
@c @kbd{C-x C-o} (@code{delete-blank-lines}).  @kbd{C-x C-o} in a run of
@c several blank lines deletes all but one of them.  @kbd{C-x C-o} on a
@c solitary blank line deletes that blank line.  When point is on a
@c nonblank line, @kbd{C-x C-o} deletes any blank lines following that
@c nonblank line.
余分な空行を削除するには、
コマンド@kbd{C-x C-o}（@code{delete-blank-lines}）を使います。
連続する複数の空行の中で@kbd{C-x C-o}を実行すると、
1行を残してすべての空行を削除します。
空行が1行だけの場合、その空行自体を削除します。
空行でない行にポイントがある場合、
その行に続くすべての空行を削除します。

@node Continuation Lines, Position Info, Blank Lines, Basic
@c @section Continuation Lines
@section 継続行

@c @cindex continuation line
@cindex 継続行
@c @cindex wrapping
@cindex 折り返し
@c @cindex line wrapping
@cindex 行の折り返し
@c   If you add too many characters to one line without breaking it with
@c @key{RET}, the line will grow to occupy two (or more) lines on the screen,
@c with a @samp{\} at the extreme right margin of all but the last of them.
@c The @samp{\} says that the following screen line is not really a distinct
@c line in the text, but just the @dfn{continuation} of a line too long to fit
@c the screen.  Continuation is also called @dfn{line wrapping}.
@key{RET}で分割せずに1行に文字を加え続けると、
その行は画面上で2行以上を占めるようになります。
このとき、そのような行の最後の行を除くすべての行の右端には、
@samp{\}が表示されます。
この@samp{\}は、画面上の後続の行はテキスト内の独立した行ではなく、
画面に収まりきらない長い行が@dfn{継続}（continuation）
していることを意味します。
この継続を、@dfn{折り返し}（wrapping）とも呼びます。

@c   Sometimes it is nice to have Emacs insert newlines automatically when
@c a line gets too long.  Continuation on the screen does not do that.  Use
@c Auto Fill mode (@pxref{Filling}) if that's what you want.
行が長くなりすぎたときにEmacsが自動的に改行を挿入すると便利なことがあります。
画面上での継続は、このようには機能しません。
自動的に改行するようにするには、
自動詰め込み（auto-fill）モード（@pxref{Filling}）を使います。

@vindex truncate-lines
@c @cindex truncation
@cindex 切り捨て
@c   As an alternative to continuation, Emacs can display long lines by
@c @dfn{truncation}.  This means that all the characters that do not fit in
@c the width of the screen or window do not appear at all.  They remain in
@c the buffer, temporarily invisible.  @samp{$} is used in the last column
@c instead of @samp{\} to inform you that truncation is in effect.
継続のかわりの方法として、Emacsは長い行を@dfn{切り捨て}（truncation）て
表示することもできます。
つまり、画面やウィンドウの幅に収まりきらない文字は表示しません。
もちろん、一時的に見えないだけで、バッファ内には存在しています。
切り捨てていることを示すために、
@samp{\}ではなく@samp{$}を右端に用います。

@c   Truncation instead of continuation happens whenever horizontal
@c scrolling is in use, and optionally in all side-by-side windows
@c (@pxref{Windows}).  You can enable truncation for a particular buffer by
@c setting the variable @code{truncate-lines} to non-@code{nil} in that
@c buffer.  (@xref{Variables}.)  Altering the value of
@c @code{truncate-lines} makes it local to the current buffer; until that
@c time, the default value is in effect.  The default is initially
@c @code{nil}.  @xref{Locals}.
水平スクロールを使っていたり、ウィンドウを左右に並べていると、
継続のかわりに切り捨て表示します（@pxref{Windows}）。
特定のバッファの変数@code{truncate-lines}に@code{nil}以外を設定すると、
そのバッファを切り捨て表示にできます（@pxref{Variables}）。
変数@code{truncate-lines}の値を変更すると、
この変数はカレントバッファにローカルになります。
そうするまでは、デフォルト値が使われます。
デフォルトの初期値は@code{nil}です。
@xref{Locals}。

@c   @xref{Display Vars}, for additional variables that affect how text is
@c displayed.
テキストの表示方法に影響する変数については、@xref{Display Vars}。

@node Position Info, Arguments, Continuation Lines, Basic
@c @section Cursor Position Information
@section カーソル位置の情報

@c   Here are commands to get information about the size and position of
@c parts of the buffer, and to count lines.
バッファのある部分の大きさや位置に関する情報を得るコマンドや
行を数えるコマンドを紹介します。

@table @kbd
@item M-x what-page
@c Print page number of point, and line number within page.
ポイントがあるページの番号とそのページ内での行番号を表示する。
@item M-x what-line
@c Print line number of point in the buffer.
ポイントがある行のバッファ内での行番号を表示する。
@item M-x line-number-mode
@c Toggle automatic display of current line number.
現在行の自動行番号表示をオン／オフする。
@item M-=
@c Print number of lines in the current region (@code{count-lines-region}).
@c @xref{Mark}, for information about the region.
カレントリージョンの行数を表示する（@code{count-lines-region}）。
リージョンに関しては、@pxref{Mark}。
@item C-x =
@c Print character code of character after point, character position of
@c point, and column of point (@code{what-cursor-position}).
ポイントの直後にある印字文字の文字コード、ポイントの文字位置、
ポイントの桁位置を表示する（@code{what-cursor-position}）。
@end table

@findex what-page
@findex what-line
@c @cindex line number commands
@c @cindex location of point
@c @cindex cursor location
@c @cindex point location
@cindex 行番号コマンド
@cindex ポイント位置
@cindex カーソル位置
@c   There are two commands for working with line numbers.  @kbd{M-x
@c what-line} computes the current line number and displays it in the echo
@c area.  To go to a given line by number, use @kbd{M-x goto-line}; it
@c prompts you for the number.  These line numbers count from one at the
@c beginning of the buffer.
行番号に関するコマンドは2つあります。
@kbd{M-x what-line}は現在行の行番号を計算して、エコー領域に表示します。
指定した行番号の行へ移動するには、@kbd{M-x goto-line}を使います。
このコマンドは、行番号を聞いてきます。
これらの行番号は、バッファの先頭を1行目と数えます。

@c   You can also see the current line number in the mode line; @xref{Mode
@c Line}.  If you narrow the buffer, then the line number in the mode line
@c is relative to the accessible portion (@pxref{Narrowing}).  By contrast,
@c @code{what-line} shows both the line number relative to the narrowed
@c region and the line number relative to the whole buffer.
モード行で現在行の行番号を知ることもできます。
@xref{Mode Line}。
バッファをナロイングしてある場合、
モード行中の行番号は参照可能な範囲内での相対的なものになります
（@pxref{Narrowing}）。
対照的に、@code{what-line}は、
ナロイングされた範囲内での行番号と、
バッファ全体での行番号の両方を表示します。

@c   By contrast, @kbd{M-x what-page} counts pages from the beginning of
@c the file, and counts lines within the page, printing both numbers.
@c @xref{Pages}.
これに対し、@kbd{M-x what-page}は、ファイルの先頭からページを数え、
さらにページ内での行番号も数えて、両方を表示します。
@xref{Pages}。

@kindex M-=
@findex count-lines-region
@c   While on this subject, we might as well mention @kbd{M-=} (@code{count-lines-region}),
@c which prints the number of lines in the region (@pxref{Mark}).
@c @xref{Pages}, for the command @kbd{C-x l} which counts the lines in the
@c current page.
この話題に関連して、
@kbd{M-=}（@code{count-lines-region}）も説明しておきましょう。
これは、リージョンの行数を数えて表示します（@pxref{Mark}）。
カレントページの行数を数えるコマンド@kbd{C-x l}については、@xref{Pages}。

@kindex C-x =
@findex what-cursor-position
@c   The command @kbd{C-x =} (@code{what-cursor-position}) can be used to find out
@c the column that the cursor is in, and other miscellaneous information about
@c point.  It prints a line in the echo area that looks like this:
コマンド@kbd{C-x =}（@code{what-cursor-position}）は、
カーソルがある箇所の桁位置を求めたり、
ポイントに関するその他の種々の情報を得るために使います。
エコー領域につぎのように表示します。

@smallexample
Char: c (0143, 99, 0x63)  point=21044 of 26883(78%)  column 53 
@end smallexample

@noindent
@c (In fact, this is the output produced when point is before the
@c @samp{column} in the example.)
（これは、例の中の@samp{column}のまえにポイントがあるときの実際の出力。）

@c   The four values after @samp{Char:} describe the character that follows
@c point, first by showing it and then by giving its character code in
@c octal, decimal and hex.  For a non-ASCII multibyte character, these are
@c followed by @samp{ext} and the character's representation, in hex, in
@c the buffer's coding system, if that coding system encodes the character
@c safely and with a single byte (@pxref{Coding Systems}).  If the
@c character's encoding is longer than one byte, Emacs shows @samp{ext ...}.
@samp{Char:}のあとの4つの値は、ポイントの直後の文字を表していて、
文字そのもの、続いて、文字コードの8進表示、10進表示、16進表示です。
非ASCIIのマルチバイト文字に対しては、
バッファのコーディングシステムにおいて当該文字をまちがいなく、かつ、
単一バイトで符号化できる場合には、
@samp{ext}とバッファのコーディングシステムで表した文字コードの16進表示が
続きます（@pxref{Coding Systems}）。
文字の符号が1バイトより長い場合には、
Emacsは@samp{ext ...}を表示します。

@c   @samp{point=} is followed by the position of point expressed as a character
@c count.  The front of the buffer counts as position 1, one character later
@c as 2, and so on.  The next, larger, number is the total number of characters
@c in the buffer.  Afterward in parentheses comes the position expressed as a
@c percentage of the total size.
@samp{point=}のあとは、ポイント位置を文字単位に数えたものです。
バッファの先頭を位置1、つぎの1文字を2、というように数えます。
つぎの大きな数字はバッファ内の総文字数です。
続く括弧の中は、ポイント位置の全サイズに対する百分率です。

@c   @samp{column} is followed by the horizontal position of point, in
@c columns from the left edge of the window.
@samp{column}に続くものは、ウィンドウの左端からの桁数で表した
ポイントの水平位置です。

@c   If the buffer has been narrowed, making some of the text at the
@c beginning and the end temporarily inaccessible, @kbd{C-x =} prints
@c additional text describing the currently accessible range.  For example, it
@c might display this:
バッファをナロイングしていて、バッファの先頭と末尾のテキストの一部が
表示されていない場合、@kbd{C-x =}は、
現在参照可能な範囲に関する情報も表示します。
たとえばつぎのようになります。

@smallexample
Char: C (0103, 67, 0x43)  point=252 of 889(28%) <231 - 599>  column 0 
@end smallexample

@noindent
@c where the two extra numbers give the smallest and largest character
@c position that point is allowed to assume.  The characters between those
@c two positions are the accessible ones.  @xref{Narrowing}.
ここで、新たに追加された2つの数字が、
ポイントを設定できる文字位置の下限と上限を示します。
これら2つの位置のあいだの文字が参照可能な文字です。
@xref{Narrowing}。

@c   If point is at the end of the buffer (or the end of the accessible
@c part), the @w{@kbd{C-x =}} output does not describe a character after
@c point.  The output might look like this:
ポイントがバッファの末尾（あるいは参照可能な部分の末尾）にある場合、
@w{@kbd{C-x =}}は、ポイントの直後の文字に関する情報は表示しません。
出力はつぎのようになります。

@smallexample
point=26957 of 26956(100%)  column 0 
@end smallexample

@c   @w{@kbd{C-u C-x =}} displays additional information about a character,
@c in place of the buffer coordinates and column: the character set name
@c and the codes that identify the character within that character set;
@c ASCII characters are identified as belonging to the @code{ASCII}
@c character set.  In addition, the full character encoding, even if it
@c takes more than a single byte, is shown after @samp{ext}.  Here's an
@c example for a Latin-1 character A with a grave accent in a buffer whose
@c coding system is iso-2022-7bit@footnote{On terminals that support
@c Latin-1 characters, the character shown after @samp{Char:} is displayed
@c as the actual glyph of A with grave accent.}:
@w{@kbd{C-u C-x =}}は、バッファ内の位置と桁位置のかわりに、
文字に関する追加情報、つまり、
文字集合名とその文字集合内でその文字を識別するコードを表示します。
ASCII文字は、文字集合@code{ASCII}に属するものと識別します。
さらに、文字を完全に符号化するのに単一バイトより多く必要な場合であっても、
@samp{ext}のあとに文字コードを表示します。
コーディングシステムがiso-2022-7bitであるバッファ内にある
Latin-1のアクサングレーブ付きの文字Aの例を示します。
@footnote{Latin-1文字を表示できる端末であれば、
@samp{Char:}のあとに表示される文字は、実際に、
アクサングレーブ付きの文字Aになる。}

@example
Char: @`A (04300, 2240, 0x8c0, ext ESC , A @@) (latin-iso8859-1 64)
@end example

@node Arguments, Repeating, Position Info, Basic
@c @section Numeric Arguments
@section 数引数
@c @cindex numeric arguments
@c @cindex prefix arguments
@c @cindex arguments, numeric
@c @cindex arguments, prefix
@cindex 数引数
@cindex 前置引数
@cindex 引数、数字
@cindex 引数、前置

@c   In mathematics and computer usage, the word @dfn{argument} means
@c ``data provided to a function or operation.''  You can give any Emacs
@c command a @dfn{numeric argument} (also called a @dfn{prefix argument}).
@c Some commands interpret the argument as a repetition count.  For
@c example, @kbd{C-f} with an argument of ten moves forward ten characters
@c instead of one.  With these commands, no argument is equivalent to an
@c argument of one.  Negative arguments tell most such commands to move or
@c act in the opposite direction.
数学や計算機の用語では、@dfn{引数}（argument）という単語は
『関数や操作に与えるデータ』を意味します。
Emacsのすべてのコマンドには、@dfn{数引数}（numeric argument）
（@dfn{前置引数}（prefix argument）とも呼ぶ）を指定できます。
コマンドによっては、引数を反復回数として解釈します。
たとえば、引数10を@kbd{C-f}に指定すると、
カーソルを通常の1文字ではなく、10文字分前向きに移動します。
これらのコマンドでは、引数を指定しないと引数1を指定したのと同等になります。
この種のコマンドの多くでは、負の引数を指定すると、
逆向きの移動や逆の操作を指示することになります。

@kindex M-1
@kindex M-@t{-}
@findex digit-argument
@findex negative-argument
@c   If your terminal keyboard has a @key{META} key, the easiest way to
@c specify a numeric argument is to type digits and/or a minus sign while
@c holding down the @key{META} key.  For example,
端末のキーボードに@key{META}キーがある場合、
数引数を入力するもっとも簡単な方法は、
@key{META}キーを押し下げたままで、数字やマイナス記号を打ちます。
たとえば、
@example
M-5 C-n
@end example
@noindent
@c would move down five lines.  The characters @kbd{Meta-1}, @kbd{Meta-2},
@c and so on, as well as @kbd{Meta--}, do this because they are keys bound
@c to commands (@code{digit-argument} and @code{negative-argument}) that
@c are defined to contribute to an argument for the next command.  Digits
@c and @kbd{-} modified with Control, or Control and Meta, also specify
@c numeric arguments.
は、カーソルを5行下に移動します。
@kbd{Meta-1}、@kbd{Meta-2}、@kbd{Meta--}などの文字がこのように動作するのは、
これらのキーが、後続のコマンドに引数を与えるように定義されたコマンド
（@code{digit-argument}と@code{negative-argument}）に
バインドされているからです。
コントロールやコントロールとメタで修飾した数字と@kbd{-}も、
同様に数引数を指定します。

@kindex C-u
@findex universal-argument
@c   Another way of specifying an argument is to use the @kbd{C-u}
@c (@code{universal-argument}) command followed by the digits of the
@c argument.  With @kbd{C-u}, you can type the argument digits without
@c holding down modifier keys; @kbd{C-u} works on all terminals.  To type a
@c negative argument, type a minus sign after @kbd{C-u}.  Just a minus sign
@c without digits normally means @minus{}1.
引数を指定する別の方法は、
@kbd{C-u}（@code{universal-argument}）コマンドに続けて
引数の数字を入力することです。
@kbd{C-u}では、修飾キーを押し下げ続けることなく引数の数字を打てます。
@kbd{C-u}はすべての端末で使えます。
負の引数を指定するには、@kbd{C-u}のあとにまずマイナス記号を打ちます。
マイナス記号だけだと@minus{}1を意味します。

@c   @kbd{C-u} followed by a character which is neither a digit nor a minus
@c sign has the special meaning of ``multiply by four.''  It multiplies the
@c argument for the next command by four.  @kbd{C-u} twice multiplies it by
@c sixteen.  Thus, @kbd{C-u C-u C-f} moves forward sixteen characters.  This
@c is a good way to move forward ``fast,'' since it moves about 1/5 of a line
@c in the usual size screen.  Other useful combinations are @kbd{C-u C-n},
@c @kbd{C-u C-u C-n} (move down a good fraction of a screen), @kbd{C-u C-u
@c C-o} (make ``a lot'' of blank lines), and @kbd{C-u C-k} (kill four
@c lines).@refill
@kbd{C-u}のあとに数字でもマイナス記号でもない文字を打つと、
『4倍する』という特別な意味になります。
つまり、後続のコマンドに渡す引数を4倍します。
@kbd{C-u}を2回打つと、引数を16倍します。
したがって、@kbd{C-u C-u C-f}は、カーソルを前向きに16文字分移動します。
16文字は通常の画面で約1/5行に相当するので、
カーソルを『速く』移動させたい場合に便利な方法です。
便利な他の組み合せは、
@kbd{C-u C-n}や@kbd{C-u C-u C-n}（画面の下方への移動に便利）、
@kbd{C-u C-u C-o}（『数多く』の空行を作る）、
@kbd{C-u C-k}（4行キルする）です。

@c   Some commands care only about whether there is an argument, and not about
@c its value.  For example, the command @kbd{M-q} (@code{fill-paragraph}) with
@c no argument fills text; with an argument, it justifies the text as well.
@c (@xref{Filling}, for more information on @kbd{M-q}.)  Plain @kbd{C-u} is a
@c handy way of providing an argument for such commands.
コマンドによっては、引数の値ではなく、引数の有無だけを問題にします。
たとえば、コマンド@kbd{M-q}（@code{fill-paragraph}）に引数を指定しないと
テキストの詰め込みのみを行います。
引数を指定すると、さらに幅揃えも行います。
（@kbd{M-q}に関する詳細は、@pxref{Filling}。）
@kbd{C-u}だけを使えば、このようなコマンドに簡単に引数を指定できます。

@c   Some commands use the value of the argument as a repeat count, but do
@c something peculiar when there is no argument.  For example, the command
@c @kbd{C-k} (@code{kill-line}) with argument @var{n} kills @var{n} lines,
@c including their terminating newlines.  But @kbd{C-k} with no argument is
@c special: it kills the text up to the next newline, or, if point is right at
@c the end of the line, it kills the newline itself.  Thus, two @kbd{C-k}
@c commands with no arguments can kill a nonblank line, just like @kbd{C-k}
@c with an argument of one.  (@xref{Killing}, for more information on
@c @kbd{C-k}.)@refill
引数の値を反復回数として使うにも関わらず、
引数がないと特別な動作をするコマンドもあります。
たとえば、@kbd{C-k}（@code{kill-line}）に引数@var{n}を指定すると、
行区切りの改行も含めて@var{n}行をキルします。
これに対し、引数を指定しない場合は特別な動作となります。
つまり、つぎの改行文字までのテキストをキルするか、
行末にポイントがある場合は改行そのものをキルします。
したがって、引数を指定せずに@kbd{C-k}を2回実行すると、
引数1を指定した@kbd{C-k}と同様に、空行でない1行をキルします。
（@kbd{C-k}の詳細については、@pxref{Killing}。）

@c   A few commands treat a plain @kbd{C-u} differently from an ordinary
@c argument.  A few others may treat an argument of just a minus sign
@c differently from an argument of @minus{}1.  These unusual cases are
@c described when they come up; they are always for reasons of convenience
@c of use of the individual command.
いくつかのコマンドは、@kbd{C-u}だけの引数を通常の引数とは
異なるものとして扱います。
また、マイナス記号のみの引数を@minus{}1と区別するコマンドもあります。
これらの例外については、必要になったときに説明します。
これらの例外は、それぞれのコマンドを使いやすくするためにあります。

@c   You can use a numeric argument to insert multiple copies of a
@c character.  This is straightforward unless the character is a digit; for
@c example, @kbd{C-u 6 4 a} inserts 64 copies of the character @samp{a}.
@c But this does not work for inserting digits; @kbd{C-u 6 4 1} specifies
@c an argument of 641, rather than inserting anything.  To separate the
@c digit to insert from the argument, type another @kbd{C-u}; for example,
@c @kbd{C-u 6 4 C-u 1} does insert 64 copies of the character @samp{1}.
数引数を使って、文字のコピーを複数個挿入することもできます。
この操作は、数字以外の文字ならば簡単です。
たとえば、@kbd{C-u 6 4 a}で、文字@samp{a}を64個挿入できます。
しかし、数字では機能しません。
@kbd{C-u 6 4 1}は、引数が641であることを意味し、何も挿入しません。
引数と挿入したい数字を区切るには、もう1つ@kbd{C-u}を打ちます。
たとえば、@kbd{C-u 6 4 C-u 1}で、数字@samp{1}を64個挿入できます。

@c   We use the term ``prefix argument'' as well as ``numeric argument'' to
@c emphasize that you type the argument before the command, and to
@c distinguish these arguments from minibuffer arguments that come after
@c the command.
コマンドのまえに引数を打つということを強調するために、また、
コマンドのあとのミニバッファ引数と区別するために、
『数引数』と同様に用語『前置引数』を使います。

@node Repeating,  , Arguments, Basic
@c @section Repeating a Command
@section コマンドを繰り返す
@c @cindex repeating a command
@cindex コマンドを繰り返す

@kindex C-x z
@findex repeat
@c   The command @kbd{C-x z} (@code{repeat}) provides another way to repeat
@c an Emacs command many times.  This command repeats the previous Emacs
@c command, whatever that was.  Repeating a command uses the same arguments
@c that were used before; it does not read new arguments each time.
コマンド@kbd{C-x z}（@code{repeat}）は、
Emacsコマンドを何回も反復する別の方法です。
このコマンドは、直前のEmacsコマンドが何であっても、それを繰り返します。
繰り返されるコマンドは、まえと同じ引数を使います。
毎回、新たに引数を読むことはしません。

@c   To repeat the command more than once, type additional @kbd{z}'s: each
@c @kbd{z} repeats the command one more time.  Repetition ends when you
@c type a character other than @kbd{z}, or press a mouse button.
コマンドを2回以上繰り返すには、@kbd{z}を追加して打ちます。
1つの@kbd{z}で、コマンドを1回繰り返します。
@kbd{z}以外の文字を打つか、マウスボタンを押すと、
繰り返しを終了します。

@c   For example, suppose you type @kbd{C-u 2 0 C-d} to delete 20
@c characters.  You can repeat that command (including its argument) three
@c additional times, to delete a total of 80 characters, by typing @kbd{C-x
@c z z z}.  The first @kbd{C-x z} repeats the command once, and each
@c subsequent @kbd{z} repeats it once again.
たとえば、20文字削除するために@kbd{C-u 2 0 C-d}と打ったとしましょう。
@kbd{C-x z z z}と打てば、
（引数を含めて）削除コマンドをさらに3回繰り返し、全部で80文字削除できます。
始めの@kbd{C-x z}でコマンドを1回繰り返し、
そのあとのそれぞれの@kbd{z}で1回ずつ繰り返します。

