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

    1: @c =============================================================
    2: @c = 元 翻 訳: 高汐一紀@電気通信大学
    3: @c = 加筆修正: 大木敦雄@大塚.筑波大学 = 1998/11/25
    4: @c = 20.4改訂: 大木敦雄@大塚.筑波大学 = 1999/09/12
    5: @c = 20.6改訂: 大木敦雄@大塚.筑波大学 = 2000/03/03
    6: @c =============================================================
    7: @c This is part of the Emacs manual.
    8: @c Copyright (C) 1985,86,87,93,94,95,97,2000 Free Software Foundation, Inc.
    9: @c See file emacs.texi for copying conditions.
   10: @iftex
   11: @c @chapter Killing and Moving Text
   12: @chapter テキストのキルと移動
   14: @c   @dfn{Killing} means erasing text and copying it into the @dfn{kill
   15: @c ring}, from which it can be retrieved by @dfn{yanking} it.  Some systems
   16: @c use the terms ``cutting'' and ``pasting'' for these operations.
   17: @dfn{キル}(kill)とは、テキストを消しさり、
   18: それを@dfn{キルリング}(kill ring)にコピーすることを意味します。
   19: キルリングからは、@dfn{ヤンク}(yank)することで、
   20: テキストを取り出すことができます。
   21: これらの操作を『カット』と『ペースト』と呼ぶシステムもあります。
   23: @c   The commonest way of moving or copying text within Emacs is to kill it
   24: @c and later yank it elsewhere in one or more places.  This is very safe
   25: @c because Emacs remembers several recent kills, not just the last one.  It
   26: @c is versatile, because the many commands for killing syntactic units can
   27: @c also be used for moving those units.  But there are other ways of
   28: @c copying text for special purposes.
   29: Emacsにおいてテキストを移動したりコピーしたりするもっとも一般的な方法は、
   30: テキストをキルして、あとで数箇所にヤンクすることです。
   31: この方法はとても安全です。
   32: というのは、直前の1回のキルだけでなく、
   33: ここ最近の数回分のキルした内容を記録しているからです。
   34: 構文単位でキルする多くのコマンドは、
   35: 構文単位のテキスト移動にも使えるので、用途が広いともいえます。
   36: 他にも、特別な目的のためにテキストをコピーする方法があります。
   38: @c   Emacs has only one kill ring for all buffers, so you can kill text in
   39: @c one buffer and yank it in another buffer.
   40: Emacsには、すべてのバッファに対してたった1つのキルリングしかありません。
   41: そのため、あるバッファでキルしたテキストを
   42: 別のバッファにヤンクできます。
   44: @end iftex
   46: @node Killing, Yanking, Mark, Top
   47: @c @section Deletion and Killing
   48: @section 削除とキル
   50: @c @cindex killing text
   51: @c @cindex cutting text
   52: @c @cindex deletion
   53: @cindex テキストのキル
   54: @cindex テキストのカット
   55: @cindex 削除
   56: @c   Most commands which erase text from the buffer save it in the kill
   57: @c ring so that you can move or copy it to other parts of the buffer.
   58: @c These commands are known as @dfn{kill} commands.  The rest of the
   59: @c commands that erase text do not save it in the kill ring; they are known
   60: @c as @dfn{delete} commands.  (This distinction is made only for erasure of
   61: @c text in the buffer.)  If you do a kill or delete command by mistake, you
   62: @c can use the @kbd{C-x u} (@code{undo}) command to undo it
   63: @c (@pxref{Undo}).
   64: バッファからテキストを消しさるコマンドのほとんどは、
   65: そのテキストをキルリングにコピーしておくので、
   66: バッファの他の部分にそのテキストを移動したりコピーしたりできます。
   67: これらのコマンドを、@dfn{キル}(kill)コマンドと呼びます。
   68: それ以外の『テキストを消すコマンド』は、
   69: テキストをキルリングに保存しません。
   70: これらを@dfn{削除}(delete)コマンドと呼びます。
   71: (両者を区別するのは、バッファ内のテキストを消す場合だけ。)
   72: キルコマンドや削除コマンドを誤って実行してしまった場合には、
   73: @kbd{C-x u}(@code{undo})コマンドを使って、もとに戻すことができます。
   75: @c   The delete commands include @kbd{C-d} (@code{delete-char}) and
   76: @c @key{DEL} (@code{delete-backward-char}), which delete only one character at
   77: @c a time, and those commands that delete only spaces or newlines.  Commands
   78: @c that can destroy significant amounts of nontrivial data generally kill.
   79: @c The commands' names and individual descriptions use the words @samp{kill}
   80: @c and @samp{delete} to say which they do.
   81: 削除コマンドには、一度に1つの文字だけを削除する
   82: @kbd{C-d}(@code{delete-char})や@key{DEL}(@code{delete-backward-char})、
   83: 空白や改行だけを削除するコマンドがあります。
   84: 単純ではないデータをかなりの分量で破壊する可能性のあるコマンドは、
   85: 一般にキルを行います。
   86: コマンド名や個々の説明では、そのコマンドがどちらの働きをするかによって、
   87: @samp{キル}(kill)と@samp{削除}(delete)を使い分けています。
   89: @menu
   90: * Deletion::            Commands for deleting small amounts of text and
   91:                           blank areas.
   92: * Killing by Lines::    How to kill entire lines of text at one time.
   93: * Other Kill Commands:: Commands to kill large regions of text and
   94:                           syntactic units such as words and sentences. 
   95: @end menu
   97: @node Deletion, Killing by Lines, , Killing
   98: @c @subsection Deletion
   99: @subsection 削除
  100: @c ??? Should be backward-delete-char
  101: @findex delete-backward-char
  102: @findex delete-char
  103: @kindex DEL
  104: @kindex C-d
  106: @table @kbd
  107: @item C-d
  108: @c Delete next character (@code{delete-char}).
  109: つぎの文字を削除する(@code{delete-char})。
  110: @item @key{DEL}
  111: @c Delete previous character (@code{delete-backward-char}).
  112: まえの文字を削除する(@code{delete-backward-char})。
  113: @item M-\
  114: @c Delete spaces and tabs around point (@code{delete-horizontal-space}).
  115: ポイントの周りの空白とタブを削除する(@code{delete-horizontal-space})。
  116: @item M-@key{SPC}
  117: @c Delete spaces and tabs around point, leaving one space
  118: @c (@code{just-one-space}).
  119: ポイントの周りの空白とタブを削除し、空白を1個だけ残す
  120: (@code{just-one-space})。
  121: @item C-x C-o
  122: @c Delete blank lines around the current line (@code{delete-blank-lines}).
  123: 現在行の周りの空行を削除する(@code{delete-blank-lines})。
  124: @item M-^
  125: @c Join two lines by deleting the intervening newline, along with any
  126: @c indentation following it (@code{delete-indentation}).
  127: 行間の改行とそれに続く字下げを削除して2行を繋げる
  128: (@code{delete-indentation})。
  129: @end table
  131: @c   The most basic delete commands are @kbd{C-d} (@code{delete-char}) and
  132: @c @key{DEL} (@code{delete-backward-char}).  @kbd{C-d} deletes the
  133: @c character after point, the one the cursor is ``on top of.''  This
  134: @c doesn't move point.  @key{DEL} deletes the character before the cursor,
  135: @c and moves point back.  You can delete newlines like any other characters
  136: @c in the buffer; deleting a newline joins two lines.  Actually, @kbd{C-d}
  137: @c and @key{DEL} aren't always delete commands; when given arguments, they
  138: @c kill instead, since they can erase more than one character this way.
  139: もっとも基本的な削除コマンドは、@kbd{C-d}(@code{delete-char})と
  140: @key{DEL}(@code{delete-backward-char})です。
  141: @kbd{C-d}はポイントの直後の文字、
  142: つまり、カーソルが重なっている文字を削除します。
  143: このコマンドでは、ポイントは動きません。
  144: @key{DEL}はカーソルの直前の文字を削除して、
  145: ポイントを1つまえに移動します。
  146: バッファ内の他の文字と同様に、改行も削除できます。
  147: 改行を削除すると、2つの行が繋がります。
  148: 実際には、@kbd{C-d}と@key{DEL}がつねに削除コマンドであるわけではありません。
  149: 引数を指定するとキルコマンドとなり、
  150: 同じ方法で2文字以上を消すことができます。
  152: @kindex M-\
  153: @findex delete-horizontal-space
  154: @kindex M-SPC
  155: @findex just-one-space
  156: @c   The other delete commands are those which delete only whitespace
  157: @c characters: spaces, tabs and newlines.  @kbd{M-\}
  158: @c (@code{delete-horizontal-space}) deletes all the spaces and tab
  159: @c characters before and after point.  @kbd{M-@key{SPC}}
  160: @c (@code{just-one-space}) does likewise but leaves a single space after
  161: @c point, regardless of the number of spaces that existed previously (even
  162: @c zero).
  163: 他の削除コマンドは、空白、タブ、改行といった白文字だけを削除します。
  164: @kbd{M-\}(@code{delete-horizontal-space})は、
  165: ポイントの前後にあるすべての空白とタブ文字を削除します。
  166: @kbd{M-@key{SPC}}(@code{just-one-space})も同様に削除しますが、
  167: 今ある空白の個数に関係なく(たとえ0個でも)、
  168: ポイントの直後に空白を1個だけ残します。
  170: @c   @kbd{C-x C-o} (@code{delete-blank-lines}) deletes all blank lines
  171: @c after the current line.  If the current line is blank, it deletes all
  172: @c blank lines preceding the current line as well (leaving one blank line,
  173: @c the current line).
  174: @kbd{C-x C-o}(@code{delete-blank-lines})は、
  175: 現在行に続くすべての空行を削除します。
  176: 現在行が空行である場合には、(空行である現在行だけを残して)
  177: 先行する空行も同様にすべて削除します。
  179: @c   @kbd{M-^} (@code{delete-indentation}) joins the current line and the
  180: @c previous line, by deleting a newline and all surrounding spaces, usually
  181: @c leaving a single space.  @xref{Indentation,M-^}.
  182: @kbd{M-^}(@code{delete-indentation})は、
  183: 改行とその周りの空白を削除して、
  184: 通常は空白を1個残して現在行と先行する行を繋げます。
  185: @xref{Indentation,M-^}。
  187: @node Killing by Lines, Other Kill Commands, Deletion, Killing
  188: @c @subsection Killing by Lines
  189: @subsection 行単位のキル
  191: @table @kbd
  192: @item C-k
  193: @c Kill rest of line or one or more lines (@code{kill-line}).
  194: 行の残りの部分、あるいは、行全体を1行以上キルする(@code{kill-line})。
  195: @end table
  197: @kindex C-k
  198: @findex kill-line
  199: @c   The simplest kill command is @kbd{C-k}.  If given at the beginning of
  200: @c a line, it kills all the text on the line, leaving it blank.  When used
  201: @c on a blank line, it kills the whole line including its newline.  To kill
  202: @c an entire non-blank line, go to the beginning and type @kbd{C-k} twice.
  203: もっとも単純なキルコマンドは@kbd{C-k}です。
  204: 行の先頭で使うと、その行のすべてのテキストをキルして、空行にします。
  205: 空行で使うと、改行を含めてその行を完全にキルします。
  206: 空行でない行を完全にキルするには、行頭で@kbd{C-k}を2回打ちます。
  208: @c   More generally, @kbd{C-k} kills from point up to the end of the line,
  209: @c unless it is at the end of a line.  In that case it kills the newline
  210: @c following point, thus merging the next line into the current one.
  211: @c Spaces and tabs that you can't see at the end of the line are ignored
  212: @c when deciding which case applies, so if point appears to be at the end
  213: @c of the line, you can be sure @kbd{C-k} will kill the newline.
  214: 一般に、@kbd{C-k}は、行末でなければ、
  215: ポイントからその行の末尾までをキルします。
  216: 行末では、ポイントのうしろの改行をキルするので、
  217: 現在行と後続の行が繋がります。
  218: どちらの動作をするか決めるときには、
  219: 行末にあって見にくい空白やタブを無視しますから、
  220: ポイントが行末にあるように見えていれば、
  221: @kbd{C-k}で改行がキルされると考えてください。
  223: @c   When @kbd{C-k} is given a positive argument, it kills that many lines
  224: @c and the newlines that follow them (however, text on the current line
  225: @c before point is spared).  With a negative argument @minus{}@var{n}, it
  226: @c kills @var{n} lines preceding the current line (together with the text
  227: @c on the current line before point).  Thus, @kbd{C-u - 2 C-k} at the front
  228: @c of a line kills the two previous lines.
  229: @kbd{C-k}に正の引数を指定すると、
  230: その個数の行とそれらに続く改行をキルします
  231: (ただし、現在行のポイントよりまえのテキストは残す)。
  232: 負の引数@minus{}@var{n}を指定すると、
  233: @kbd{C-k}は現在行に先行する@var{n}行
  234: (と現在行のポイント位置よりまえのテキストを含めて)を削除します。
  235: つまり、ポイントが行頭にある状態で@kbd{C-u - 2 C-k}とすれば、
  236: 先行する2行をキルします。
  238: @c   @kbd{C-k} with an argument of zero kills the text before point on the
  239: @c current line.
  240: @kbd{C-k}に引数0を指定すると、
  241: 現在行のポイントよりまえのテキストをキルします。
  243: @vindex kill-whole-line
  244: @c   If the variable @code{kill-whole-line} is non-@code{nil}, @kbd{C-k} at
  245: @c the very beginning of a line kills the entire line including the
  246: @c following newline.  This variable is normally @code{nil}.
  247: 変数@code{kill-whole-line}が@code{nil}以外の場合、
  248: 行頭で@kbd{C-k}を使うと、行末の改行も含めて行全体をキルします。
  249: この変数は、通常、@code{nil}です。
  251: @node Other Kill Commands,  , Killing by Lines, Killing
  252: @c @subsection Other Kill Commands
  253: @subsection 他のキルコマンド
  254: @findex kill-region
  255: @kindex C-w
  257: @c DoubleWideCommands
  258: @table @kbd
  259: @item C-w
  260: @c Kill region (from point to the mark) (@code{kill-region}).
  261: リージョン(ポイントからマークまで)をキルする(@code{kill-region})。
  262: @item M-d
  263: @c Kill word (@code{kill-word}).  @xref{Words}.
  264: 単語をキルする(@code{kill-word})。
  265: @pxref{Words}。
  266: @item M-@key{DEL}
  267: @c Kill word backwards (@code{backward-kill-word}).
  268: 単語を後向きにキルする(@code{backward-kill-word})。
  269: @item C-x @key{DEL}
  270: @c Kill back to beginning of sentence (@code{backward-kill-sentence}).
  271: @c @xref{Sentences}.
  272: 文の先頭までを後向きにキルする(@code{backward-kill-sentence})。
  273: @pxref{Sentences}。
  274: @item M-k
  275: @c Kill to end of sentence (@code{kill-sentence}).
  276: 文の末尾までをキルする(@code{kill-sentence})。
  277: @item C-M-k
  278: @c Kill sexp (@code{kill-sexp}).  @xref{Lists}.
  279: S式をキルする(@code{kill-sexp})。
  280: @pxref{Lists}。
  281: @item M-z @var{char}
  282: @c Kill through the next occurrence of @var{char} (@code{zap-to-char}).
  283: つぎに@var{char}が現れる箇所までをキルする(@code{zap-to-char})。
  284: @end table
  286: @c   A kill command which is very general is @kbd{C-w}
  287: @c (@code{kill-region}), which kills everything between point and the
  288: @c mark.  With this command, you can kill any contiguous sequence of
  289: @c characters, if you first set the region around them.
  290: 汎用的なキルコマンドといえば@kbd{C-w}(@code{kill-region})です。
  291: このコマンドは、あらかじめ連続領域をポイントとマークで囲んでおけば、
  292: どんな連続領域でもキルできます。
  294: @kindex M-z
  295: @findex zap-to-char
  296: @c   A convenient way of killing is combined with searching: @kbd{M-z}
  297: @c (@code{zap-to-char}) reads a character and kills from point up to (and
  298: @c including) the next occurrence of that character in the buffer.  A
  299: @c numeric argument acts as a repeat count.  A negative argument means to
  300: @c search backward and kill text before point.
  301: 探索と組み合わせた便利なキルの仕方もあります。
  302: @kbd{M-z}(@code{zap-to-char})は1文字を読み取り、
  303: ポイントからバッファ内でその文字がつぎに現れる箇所までを
  304: (その文字も含めて)キルします。
  305: 数引数を指定した場合は、反復回数を意味します。
  306: 負の引数の場合は、ポイント位置から逆方向に探索し、
  307: ポイントの直前までをキルします。
  309: @c   Other syntactic units can be killed: words, with @kbd{M-@key{DEL}} and
  310: @c @kbd{M-d} (@pxref{Words}); sexps, with @kbd{C-M-k} (@pxref{Lists}); and
  311: @c sentences, with @kbd{C-x @key{DEL}} and @kbd{M-k}
  312: @c (@pxref{Sentences}).@refill
  313: 他の構文単位でもキルできます。
  314: @kbd{M-@key{DEL}}や@kbd{M-d}(@pxref{Words})で単語を、
  315: @kbd{C-M-k}(@pxref{Lists})でS式を、
  316: @kbd{C-x @key{DEL}}や@kbd{M-k}(@pxref{Sentences})で文をキルできます。
  318: @c   You can use kill commands in read-only buffers.  They don't actually
  319: @c change the buffer, and they beep to warn you of that, but they do copy
  320: @c the text you tried to kill into the kill ring, so you can yank it into
  321: @c other buffers.  Most of the kill commands move point across the text
  322: @c they copy in this way, so that successive kill commands build up a
  323: @c single kill ring entry as usual.
  324: 読み出し専用のバッファでもキルできます。
  325: 実際にはバッファに変更を加えることはありませんし、
  326: ベルを鳴らしてその旨警告を発しますが、
  327: キルしようとしたテキストはキルリングにコピーされます。
  328: ですから、別のバッファにそのテキストをヤンクできます。
  329: ほとんどのキルコマンドは、
  330: このようにコピーするテキストを越えてポイントを進めますから、
  331: 連続してキルコマンドを実行しても
  332: キルリングに入る項目は通常どおり1個だけです。
  334: @node Yanking, Accumulating Text, Killing, Top
  335: @c @section Yanking
  336: @section ヤンク
  337: @c @cindex moving text
  338: @c @cindex copying text
  339: @c @cindex kill ring
  340: @c @cindex yanking
  341: @c @cindex pasting
  342: @cindex テキストの移動
  343: @cindex テキストのコピー
  344: @cindex キルリング
  345: @cindex ヤンク
  346: @cindex ペースト
  348: @c   @dfn{Yanking} means reinserting text previously killed.  This is what
  349: @c some systems call ``pasting.''  The usual way to move or copy text is to
  350: @c kill it and then yank it elsewhere one or more times.
  351: @dfn{ヤンク}(yank)とは、
  352: 以前にキルしたテキストをバッファにふたたび挿入することです。
  353: 他のシステムでは『ペースト』と呼ぶこともあります。
  354: テキストを移動したりコピーしたりする普通の方法は、
  355: そのテキストをいったんキルしてから、別の場所に(1回以上)ヤンクすることです。
  357: @table @kbd
  358: @item C-y
  359: @c Yank last killed text (@code{yank}).
  360: 最後にキルしたテキストをヤンクする(@code{yank})。
  361: @item M-y
  362: @c Replace text just yanked with an earlier batch of killed text
  363: @c (@code{yank-pop}).
  364: たった今ヤンクしたテキストをそれより以前にキルした一塊のテキストで置き換える
  365: (@code{yank-pop})。
  366: @item M-w
  367: @c Save region as last killed text without actually killing it
  368: @c (@code{kill-ring-save}).
  369: リージョンを実際にはキルせずに、最後にキルしたテキストとして保存する
  370: (@code{kill-ring-save})。
  371: @item C-M-w
  372: @c Append next kill to last batch of killed text (@code{append-next-kill}).
  373: つぎのキルを、最後にキルした一塊のテキストに付け加える
  374: (@code{append-next-kill})。
  375: @end table
  377: @menu
  378: * Kill Ring::		Where killed text is stored.  Basic yanking.
  379: * Appending Kills::	Several kills in a row all yank together.
  380: * Earlier Kills::	Yanking something killed some time ago.
  381: @end menu
  383: @node Kill Ring, Appending Kills, , Yanking
  384: @c @subsection The Kill Ring
  385: @subsection キルリング
  387: @c   All killed text is recorded in the @dfn{kill ring}, a list of blocks of
  388: @c text that have been killed.  There is only one kill ring, shared by all
  389: @c buffers, so you can kill text in one buffer and yank it in another buffer.
  390: @c This is the usual way to move text from one file to another.
  391: @c (@xref{Accumulating Text}, for some other ways.)
  392: すべてのキルされたテキストは、キルされたテキストの塊をリストとする
  393: @dfn{キルリング}(kill ring)に記録されています。
  394: キルリングはたった1つしかなくて、すべてのバッファで共有しています。
  395: ですから、あるバッファでキルしたテキストは、
  396: 別のバッファでヤンクできます。
  397: 普通、このようにして、あるファイルから別のファイルへテキストを移動します。
  398: (別の方法については、@pxref{Accumulating Text}。)
  400: @kindex C-y
  401: @findex yank
  402: @c   The command @kbd{C-y} (@code{yank}) reinserts the text of the most recent
  403: @c kill.  It leaves the cursor at the end of the text.  It sets the mark at
  404: @c the beginning of the text.  @xref{Mark}.
  405: コマンド@kbd{C-y}(@code{yank})は、
  406: 最後にキルしたテキストをふたたび挿入します。
  407: カーソルは挿入したテキストの末尾に置かれます。
  408: マークは挿入したテキストの先頭に置かれます。
  409: @xref{Mark}。
  411: @c   @kbd{C-u C-y} leaves the cursor in front of the text, and sets the
  412: @c mark after it.  This happens only if the argument is specified with just
  413: @c a @kbd{C-u}, precisely.  Any other sort of argument, including @kbd{C-u}
  414: @c and digits, specifies an earlier kill to yank (@pxref{Earlier Kills}).
  415: @kbd{C-u C-y}は、テキストのまえにカーソルを置き、うしろにマークを置きます。
  416: 引数として@kbd{C-u}だけを指定した場合に限り、こうなります。
  417: @kbd{C-u}と数字を含めた他の引数を指定すると、
  418: いくつまえのキル内容をヤンクするかを意味します(@pxref{Earlier Kills})。
  420: @kindex M-w
  421: @findex kill-ring-save
  422: @c   To copy a block of text, you can use @kbd{M-w}
  423: @c (@code{kill-ring-save}), which copies the region into the kill ring
  424: @c without removing it from the buffer.  This is approximately equivalent
  425: @c to @kbd{C-w} followed by @kbd{C-x u}, except that @kbd{M-w} does not
  426: @c alter the undo history and does not temporarily change the screen.
  427: 一塊のテキストをコピーする場合は、
  428: @kbd{M-w}(@code{kill-ring-save})を使うとよいでしょう。
  429: このコマンドは、バッファからリージョンをキルせずに、
  430: リージョンをキルリングにコピーします。
  431: このコマンドは、@kbd{C-w}に続けて@kbd{C-x u}を実行するのとほぼ同等ですが、
  432: @kbd{M-w}はアンドゥ履歴を変更しませんし、一時的にせよ画面表示も変わりません。
  434: @node Appending Kills, Earlier Kills, Kill Ring, Yanking
  435: @c @subsection Appending Kills
  436: @subsection キルしたテキストの追加
  438: @c @cindex appending kills in the ring
  439: @c @cindex television
  440: @cindex キルテキストのリングへの追加
  441: @cindex テレビ
  442: @c   Normally, each kill command pushes a new entry onto the kill ring.
  443: @c However, two or more kill commands in a row combine their text into a
  444: @c single entry, so that a single @kbd{C-y} yanks all the text as a unit,
  445: @c just as it was before it was killed.
  446: 通常、各キルコマンドは、キルリングに新たな項目を押し込みます。
  447: しかし、連続したキルコマンドでは、
  448: それぞれでキルしたテキストを1つの項目にまとめます。
  449: そのため、1回の@kbd{C-y}で、キルするまえの状態に、
  450: それらのテキストをひとまとめにヤンクできます。
  452: @c   Thus, if you want to yank text as a unit, you need not kill all of it
  453: @c with one command; you can keep killing line after line, or word after
  454: @c word, until you have killed it all, and you can still get it all back at
  455: @c once.
  456: したがって、テキストを一塊でヤンクしたい場合でも、
  457: 1つのコマンドでそれらをキルする必要はありません。
  458: すべてをキルするまで、1行ずつ、あるいは、1単語ずつキルしていっても、
  459: 一括してもとに戻すことができます。
  461: @c   Commands that kill forward from point add onto the end of the previous
  462: @c killed text.  Commands that kill backward from point add text onto the
  463: @c beginning.  This way, any sequence of mixed forward and backward kill
  464: @c commands puts all the killed text into one entry without rearrangement.
  465: @c Numeric arguments do not break the sequence of appending kills.  For
  466: @c example, suppose the buffer contains this text:
  467: ポイント位置から前向きにキルするコマンドでは、
  468: 直前にキルしたテキストの末尾に付け加えます。
  469: ポイント位置から後向きにキルするコマンドでは、
  470: テキストの先頭に付け加えます。
  471: このように、前向き/後向きの両方のキルコマンドをどのように混ぜて実行しても、
  472: キルしたテキストの順番を崩すことなく
  473: 1つの項目としてキルリングに記録されます。
  474: 数引数を指定しても、このような追加系列が途切れることはありません。
  475: たとえば、バッファにつぎのテキストが入っていて、
  476: @point{}の位置にポイントがあるとしましょう。
  478: @example
  479: This is a line @point{}of sample text.
  480: @end example
  482: @noindent
  483: @c with point shown by @point{}.  If you type @kbd{M-d M-@key{DEL} M-d
  484: @c M-@key{DEL}}, killing alternately forward and backward, you end up with
  485: @c @samp{a line of sample} as one entry in the kill ring, and @samp{This
  486: @c is@ @ text.} in the buffer.  (Note the double space, which you can clean
  487: @c up with @kbd{M-@key{SPC}} or @kbd{M-q}.)
  488: @kbd{M-d M-@key{DEL} M-d M-@key{DEL}}と打って、
  489: 前向き/後向きと交互にキルしても、
  490: キルリングには1つの項目として@samp{a line of sample}が入り、
  491: バッファには@samp{This is@ @ text.}が残ります。
  492: (空白が2個残っていることに注意。
  493: これらは@kbd{M-@key{SPC}}や@kbd{M-q}で一掃できる。)
  495: @c   Another way to kill the same text is to move back two words with
  496: @c @kbd{M-b M-b}, then kill all four words forward with @kbd{C-u M-d}.
  497: @c This produces exactly the same results in the buffer and in the kill
  498: @c ring.  @kbd{M-f M-f C-u M-@key{DEL}} kills the same text, all going
  499: @c backward; once again, the result is the same.  The text in the kill ring
  500: @c entry always has the same order that it had in the buffer before you
  501: @c killed it.
  502: 同じようにテキストをキルするもう1つの方法は、
  503: @kbd{M-b M-b}で後向きに2語移動してから、
  504: @kbd{C-u M-d}で前向きに4語キルします。
  505: こうしても、バッファとキルリングの中身は、
  506: 先の例とまったく同じ結果になります。
  507: @kbd{M-f M-f C-u M-@key{DEL}}としても、
  508: 後向きに同じテキストをキルします。
  509: これでもやはり同じ結果が得られます。
  510: キルリングの項目内のテキストの順序は、
  511: キルするまえのバッファ内での順序と同じです。
  513: @kindex C-M-w
  514: @findex append-next-kill
  515: @c   If a kill command is separated from the last kill command by other
  516: @c commands (not just numeric arguments), it starts a new entry on the kill
  517: @c ring.  But you can force it to append by first typing the command
  518: @c @kbd{C-M-w} (@code{append-next-kill}) right before it.  The @kbd{C-M-w}
  519: @c tells the following command, if it is a kill command, to append the text
  520: @c it kills to the last killed text, instead of starting a new entry.  With
  521: @c @kbd{C-M-w}, you can kill several separated pieces of text and
  522: @c accumulate them to be yanked back in one place.@refill
  523: キルコマンドと最後のキルコマンドのあいだに
  524: (単なる数引数ではない)他のコマンドが入ると、
  525: キルリングには新たな項目が作られます。
  526: しかし、キルコマンドを打つ直前に
  527: コマンド@kbd{C-M-w}(@code{append-next-kill})を打っておけば、
  528: 既存の項目へ追加するように強制できます。
  529: @kbd{C-M-w}は、つぎがキルコマンドであれば、
  530: 新たな項目を作成するかわりにキルしたテキストを
  531: 以前にキルしたテキストに付け加えるよう指示します。
  532: @kbd{C-M-w}を使うことで、
  533: まとめて1か所にヤンクできるように、
  534: 離れた場所にあるいくつかのテキスト断片をキルして集めておけます。
  536: @c   A kill command following @kbd{M-w} does not append to the text that
  537: @c @kbd{M-w} copied into the kill ring.
  538: @kbd{M-w}に続くキルコマンドでは、
  539: @kbd{M-w}がキルリングにコピーしたテキストには付け加えません。
  541: @node Earlier Kills,  , Appending Kills, Yanking
  542: @c @subsection Yanking Earlier Kills
  543: @subsection 以前にキルしたテキストのヤンク
  545: @c @cindex yanking previous kills
  546: @cindex 先にキルしたテキストのヤンク
  547: @kindex M-y
  548: @findex yank-pop
  549: @c   To recover killed text that is no longer the most recent kill, use the
  550: @c @kbd{M-y} command (@code{yank-pop}).  It takes the text previously
  551: @c yanked and replaces it with the text from an earlier kill.  So, to
  552: @c recover the text of the next-to-the-last kill, first use @kbd{C-y} to
  553: @c yank the last kill, and then use @kbd{M-y} to replace it with the
  554: @c previous kill.  @kbd{M-y} is allowed only after a @kbd{C-y} or another
  555: @c @kbd{M-y}.
  556: 直前にキルしたものではないテキストを取り出すには、
  557: @kbd{M-y}コマンド(@code{yank-pop})を使います。
  558: @kbd{M-y}は、直前にヤンクしたテキストを
  559: それ以前にキルしたテキストで置き換えます。
  560: たとえば、最後から2つめのキルテキストを取り出すには、
  561: まず@kbd{C-y}で最後にキルしたテキストをヤンクしてから、
  562: @kbd{M-y}で1つまえのものに置き換えます。
  563: @kbd{M-y}は@kbd{C-y}や他の@kbd{M-y}の直後でしか使えません。
  565: @c   You can understand @kbd{M-y} in terms of a ``last yank'' pointer which
  566: @c points at an entry in the kill ring.  Each time you kill, the ``last
  567: @c yank'' pointer moves to the newly made entry at the front of the ring.
  568: @c @kbd{C-y} yanks the entry which the ``last yank'' pointer points to.
  569: @c @kbd{M-y} moves the ``last yank'' pointer to a different entry, and the
  570: @c text in the buffer changes to match.  Enough @kbd{M-y} commands can move
  571: @c the pointer to any entry in the ring, so you can get any entry into the
  572: @c buffer.  Eventually the pointer reaches the end of the ring; the next
  573: @c @kbd{M-y} moves it to the first entry again.
  574: キルリング内の項目を指す『最終ヤンク』ポインタを考えると、
  575: @kbd{M-y}の動作を理解しやすいでしょう。
  576: キルするたびに、『最終ヤンク』ポインタは、
  577: リングの先頭に新たに作られた項目を指します。
  578: @kbd{C-y}は、『最終ヤンク』ポインタが指す項目をヤンクします。
  579: @kbd{M-y}は、『最終ヤンク』ポインタを別の項目へ移動し、
  580: それに合わせてバッファのテキストを変更します。
  581: @kbd{M-y}コマンドを繰り返せばリング内のどの項目へもポインタを移動できるので、
  582: どの項目でもバッファに取り込めます。
  583: ポインタがリングの最後に達すると、
  584: つぎの@kbd{M-y}はポインタをふたたびリングの先頭の項目に移動します。
  586: @c   @kbd{M-y} moves the ``last yank'' pointer around the ring, but it does
  587: @c not change the order of the entries in the ring, which always runs from
  588: @c the most recent kill at the front to the oldest one still remembered.
  589: @kbd{M-y}は、リング内で『最終ヤンク』ポインタを移動しますが、
  590: リング内の項目の順番を変えることはありません。
  591: つねに、最後にキルしたものが先頭にあり、
  592: 記録に残っている最古のものが最後尾にあります。
  594: @c   @kbd{M-y} can take a numeric argument, which tells it how many entries
  595: @c to advance the ``last yank'' pointer by.  A negative argument moves the
  596: @c pointer toward the front of the ring; from the front of the ring, it
  597: @c moves ``around'' to the last entry and continues forward from there.
  598: @kbd{M-y}には数引数を指定できて、
  599: 『最終ヤンク』ポインタをいくつ進めるかを指定します。
  600: 負の引数では、ポインタをリングの先頭に向けて移動します。
  601: リングの先頭からは最後の項目へ移動し、そこから先頭に向けて移動します。
  603: @c   Once the text you are looking for is brought into the buffer, you can
  604: @c stop doing @kbd{M-y} commands and it will stay there.  It's just a copy
  605: @c of the kill ring entry, so editing it in the buffer does not change
  606: @c what's in the ring.  As long as no new killing is done, the ``last
  607: @c yank'' pointer remains at the same place in the kill ring, so repeating
  608: @c @kbd{C-y} will yank another copy of the same previous kill.
  609: 目的のテキストがバッファに入ったならば、
  610: @kbd{M-y}コマンドの繰り返しを止めれば、みつけたテキストが残ります。
  611: そのテキストはキルリングの項目のコピーなので、
  612: バッファ内で編集してもリング内の項目は変わりません。
  613: 新たにキルしない限り、『最終ヤンク』ポインタは
  614: キルリング内の同じ場所を指していますから、
  615: @kbd{C-y}を繰り返すと、
  616: 直前に取り込んだものと同じキル内容のコピーをヤンクできます。
  618: @c   If you know how many @kbd{M-y} commands it would take to find the text
  619: @c you want, you can yank that text in one step using @kbd{C-y} with a
  620: @c numeric argument.  @kbd{C-y} with an argument restores the text the
  621: @c specified number of entries back in the kill ring.  Thus, @kbd{C-u 2
  622: @c C-y} gets the next-to-the-last block of killed text.  It is equivalent
  623: @c to @kbd{C-y M-y}.  @kbd{C-y} with a numeric argument starts counting
  624: @c from the ``last yank'' pointer, and sets the ``last yank'' pointer to
  625: @c the entry that it yanks.
  626: 目的のテキストを引き出すのに
  627: @kbd{M-y}コマンドを何回使えばよいのかわかっている場合には、
  628: 数引数を指定して@kbd{C-y}を使えば、
  629: 一発で目的のテキストをヤンクできます。
  630: @kbd{C-y}に数引数を指定すると、
  631: キルリング内でその個数分だけ遡った項目のテキストを取り込みます。
  632: たとえば、@kbd{C-u 2 C-y}は最後から2番目にキルしたテキストを取り込みます。
  633: つまり、@kbd{C-y M-y}とするのと等価です。
  634: 数引数を指定した@kbd{C-y}は、『最終ヤンク』ポインタの場所から
  635: 数え始め、ヤンクする項目にポイントを移動します。
  637: @vindex kill-ring-max
  638: @c   The length of the kill ring is controlled by the variable
  639: @c @code{kill-ring-max}; no more than that many blocks of killed text are
  640: @c saved.
  641: キルリングの長さは、変数@code{kill-ring-max}で制御します。
  642: この個数以上のキルテキストは保存しません。
  644: @vindex kill-ring
  645: @c   The actual contents of the kill ring are stored in a variable named
  646: @c @code{kill-ring}; you can view the entire contents of the kill ring with
  647: @c the command @kbd{C-h v kill-ring}.
  648: キルリングの実際の内容は、@code{kill-ring}という名前の変数に入っています。
  649: キルリングの全内容は、コマンド@kbd{C-h v kill-ring}で見ることができます。
  651: @node Accumulating Text, Rectangles, Yanking, Top
  652: @c @section Accumulating Text
  653: @section テキストの蓄積
  654: @findex append-to-buffer
  655: @findex prepend-to-buffer
  656: @findex copy-to-buffer
  657: @findex append-to-file
  659: @c @cindex accumulating scattered text
  660: @cindex 分散したテキストの蓄積
  661: @c   Usually we copy or move text by killing it and yanking it, but there
  662: @c are other methods convenient for copying one block of text in many
  663: @c places, or for copying many scattered blocks of text into one place.  To
  664: @c copy one block to many places, store it in a register
  665: @c (@pxref{Registers}).  Here we describe the commands to accumulate
  666: @c scattered pieces of text into a buffer or into a file.
  667: 通常、テキストをコピーしたり移動したりするにはキルとヤンクで行います。
  668: しかし、一塊のテキストを何か所にもコピーしたり、
  669: 多くの箇所に分散したテキストを1か所にコピーしたりするのに
  670: 便利な方法が他にもあります。
  671: 一塊のテキストを何か所にもコピーするには、
  672: そのテキストをレジスタに保存します(@pxref{Registers})。
  673: ここでは、何か所かに分散したテキストをバッファやファイルに
  674: 蓄積するためのコマンドを説明します。
  676: @table @kbd
  677: @item M-x append-to-buffer
  678: @c Append region to contents of specified buffer.
  679: リージョンを指定したバッファの内容の末尾に付加する。
  680: @item M-x prepend-to-buffer
  681: @c Prepend region to contents of specified buffer.
  682: リージョンを指定したバッファの内容の先頭に付加する。
  683: @item M-x copy-to-buffer
  684: @c Copy region into specified buffer, deleting that buffer's old contents.
  685: リージョンを指定したバッファにコピーするが、
  686: そのバッファの古い内容は削除する。
  687: @item M-x insert-buffer
  688: @c Insert contents of specified buffer into current buffer at point.
  689: 指定したバッファの内容をカレントバッファのポイント位置に挿入する。
  690: @item M-x append-to-file
  691: @c Append region to contents of specified file, at the end.
  692: リージョンを指定したファイルの内容の末尾に付加する。
  693: @end table
  695: @c   To accumulate text into a buffer, use @kbd{M-x append-to-buffer}.
  696: @c This reads a buffer name, then inserts a copy of the region into the
  697: @c buffer specified.  If you specify a nonexistent buffer,
  698: @c @code{append-to-buffer} creates the buffer.  The text is inserted
  699: @c wherever point is in that buffer.  If you have been using the buffer for
  700: @c editing, the copied text goes into the middle of the text of the buffer,
  701: @c wherever point happens to be in it.
  702: テキストをバッファに蓄積するには、@kbd{M-x append-to-buffer}を使います。
  703: これは、バッファ名を読み取り、
  704: リージョンのコピーを指定したバッファに挿入します。
  705: 存在しないバッファを指定した場合、
  706: @code{append-to-buffer}はバッファを作成します。
  707: テキストは、そのバッファ内のポイント位置に挿入されます。
  708: バッファを編集用に使っている場合には、
  709: そのバッファ内のテキストのあいだ、
  710: その時点のポイント位置にコピーしたテキストを挿入します。
  712: @c   Point in that buffer is left at the end of the copied text, so
  713: @c successive uses of @code{append-to-buffer} accumulate the text in the
  714: @c specified buffer in the same order as they were copied.  Strictly
  715: @c speaking, @code{append-to-buffer} does not always append to the text
  716: @c already in the buffer---it appends only if point in that buffer is at the end.
  717: @c However, if @code{append-to-buffer} is the only command you use to alter
  718: @c a buffer, then point is always at the end.
  719: コピー先のバッファ内では、ポイントはコピーされたテキストの末尾に置かれます。
  720: したがって、連続して@code{append-to-buffer}を使うと、
  721: コピーした順序でバッファにテキストが蓄積されます。
  722: 厳密には、@code{append-to-buffer}は、
  723: バッファ内の既存のテキストに追加するとは限りません。
  724: そのバッファの末尾にポイントがある場合に限り、追加します。
  725: しかし、バッファを変更するコマンドが@code{append-to-buffer}だけならば、
  726: ポイントはつねに末尾に置かれています。
  728: @c   @kbd{M-x prepend-to-buffer} is just like @code{append-to-buffer}
  729: @c except that point in the other buffer is left before the copied text, so
  730: @c successive prependings add text in reverse order.  @kbd{M-x
  731: @c copy-to-buffer} is similar except that any existing text in the other
  732: @c buffer is deleted, so the buffer is left containing just the text newly
  733: @c copied into it.
  734: @kbd{M-x prepend-to-buffer}は@code{append-to-buffer}にとてもよく似ていますが、
  735: コピー先のバッファ内のポイントは、
  736: コピーしたテキストの直前に置かれる点が異なります。
  737: つまり、続けてこのコマンドを使うと、
  738: テキストは逆順に追加されていきます。
  739: @kbd{M-x copy-to-buffer}も同様ですが、
  740: 指定したバッファ内の既存のテキストを削除します。
  741: したがって、バッファには新たにコピーしたテキストだけが残ります。
  743: @c   To retrieve the accumulated text from another buffer, use the command
  744: @c @kbd{M-x insert-buffer}; this too takes @var{buffername} as an argument.
  745: @c It inserts a copy of the text in buffer @var{buffername} into the
  746: @c selected buffer.  You can alternatively select the other buffer for
  747: @c editing, then optionally move text from it by killing.  @xref{Buffers},
  748: @c for background information on buffers.
  749: 別のバッファに蓄積したテキストを取り出すには、
  750: コマンド@kbd{M-x insert-buffer}を使います。
  751: このコマンドも引数として@var{buffername}を必要とします。
  752: バッファ@var{buffername}内のテキストのコピーを
  753: 選択しているバッファに挿入します。
  754: あるいは、そのバッファを選択して編集し、
  755: 場合によってはキルしてそのバッファからテキストを移動することもできます。
  756: バッファに関する背景情報は、@xref{Buffers}。
  758: @c   Instead of accumulating text within Emacs, in a buffer, you can append
  759: @c text directly into a file with @kbd{M-x append-to-file}, which takes
  760: @c @var{filename} as an argument.  It adds the text of the region to the end
  761: @c of the specified file.  The file is changed immediately on disk.
  762: テキストをEmacsのバッファに蓄積するかわりに、
  763: @kbd{M-x append-to-file}を使って、テキストを直接ファイルに追加できます。
  764: このコマンドは引数として@var{filename}を必要とします。
  765: リージョンのテキストを指定したファイルの末尾に追加します。
  766: ファイルはディスク上でただちに更新されます。
  768: @c   You should use @code{append-to-file} only with files that are
  769: @c @emph{not} being visited in Emacs.  Using it on a file that you are
  770: @c editing in Emacs would change the file behind Emacs's back, which
  771: @c can lead to losing some of your editing.
  772: このコマンドに指定するファイルは、
  773: Emacsで訪問して@emph{いない}ファイルだけに限るべきです。
  774: Emacsで編集中のファイルを指定すると、
  775: Emacsに隠れてファイルを変更することになり、
  776: 編集内容の一部を失うことにもなりかねません。
  778: @node Rectangles, Registers, Accumulating Text, Top
  779: @c @section Rectangles
  780: @section 矩形領域
  781: @c @cindex rectangle
  782: @c @cindex columns (and rectangles)
  783: @c @cindex killing rectangular areas of text
  784: @cindex 矩形領域
  785: @cindex 桁(と矩形領域)
  786: @cindex テキストの矩形領域のキル
  788: @c   The rectangle commands operate on rectangular areas of the text: all
  789: @c the characters between a certain pair of columns, in a certain range of
  790: @c lines.  Commands are provided to kill rectangles, yank killed rectangles,
  791: @c clear them out, fill them with blanks or text, or delete them.  Rectangle
  792: @c commands are useful with text in multicolumn formats, and for changing
  793: @c text into or out of such formats.
  794: 矩形領域コマンドはテキストの矩形領域を操作します。
  795: 矩形領域のテキストとは、
  796: 2つの行の範囲内にある2つの桁位置のあいだにある文字すべてを指します。
  797: 矩形領域をキルする、キルした矩形領域をヤンクする、
  798: 矩形領域をクリアする、矩形領域を空白やテキストで充填する、
  799: 矩形領域を削除する、といったコマンドがあります。
  800: 矩形領域コマンドは、複数段に組んだテキストを操作したり、
  801: テキストをそのように組んだり戻したりする場合に便利です。
  803: @c   When you must specify a rectangle for a command to work on, you do it
  804: @c by putting the mark at one corner and point at the opposite corner.  The
  805: @c rectangle thus specified is called the @dfn{region-rectangle} because
  806: @c you control it in about the same way the region is controlled.  But
  807: @c remember that a given combination of point and mark values can be
  808: @c interpreted either as a region or as a rectangle, depending on the
  809: @c command that uses them.
  810: コマンドで操作する矩形領域を指定するには、
  811: 一方の隅にマークを設定し、その対角にポイントを置きます。
  812: このように設定した矩形領域を@dfn{矩形リージョン}
  813: (region-rectangle)と呼びます。
  814: というのも、リージョンの制御と似た方法で矩形領域を制御できるからです。
  815: しかし、ポイントとマークの組は、それを使うコマンドに依存して、
  816: リージョンとして解釈される、あるいは、
  817: 矩形領域として解釈されることに注意してください。
  819: @c   If point and the mark are in the same column, the rectangle they
  820: @c delimit is empty.  If they are in the same line, the rectangle is one
  821: @c line high.  This asymmetry between lines and columns comes about
  822: @c because point (and likewise the mark) is between two columns, but within
  823: @c a line.
  824: ポイントとマークが同じ桁位置にある場合、
  825: それらが切り分ける矩形領域は空です。
  826: 同じ行上にある場合は、矩形領域の高さは1行です。
  827: 桁と行の扱い方が非対称であるのは、
  828: ポイント(同様にマーク)は2つの桁のあいだにあるのに対し、
  829: 行ではその中にあるからです。
  831: @table @kbd
  832: @item C-x r k
  833: @c Kill the text of the region-rectangle, saving its contents as the 
  834: @c ``last killed rectangle'' (@code{kill-rectangle}).
  835: 矩形リージョンのテキストをキルし、
  836: その内容を『最後にキルした矩形領域』として保存する(@code{kill-rectangle})。
  837: @item C-x r d
  838: @c Delete the text of the region-rectangle (@code{delete-rectangle}).
  839: 矩形リージョンのテキストを削除する(@code{delete-rectangle})。
  840: @item C-x r y
  841: @c Yank the last killed rectangle with its upper left corner at point
  842: @c (@code{yank-rectangle}).
  843: 最後にキルした矩形領域をポイント位置を左上隅としてヤンクする
  844: (@code{yank-rectangle})。
  845: @item C-x r o
  846: @c Insert blank space to fill the space of the region-rectangle
  847: @c (@code{open-rectangle}).  This pushes the previous contents of the
  848: @c region-rectangle rightward.
  849: 空白で埋めた矩形リージョンを挿入する(@code{open-rectangle})。
  850: 矩形リージョンの直前の内容は右に押しやられる。
  851: @item M-x clear-rectangle
  852: @c Clear the region-rectangle by replacing its contents with spaces.
  853: 矩形リージョンのすべてのテキストを空白で置き換えて、
  854: 内容をクリアする。
  855: @item M-x delete-whitespace-rectangle
  856: @c Delete whitespace in each of the lines on the specified rectangle,
  857: @c starting from the left edge column of the rectangle.
  858: 指定した矩形領域の各行において、
  859: 矩形領域の左端から白文字を削除する。
  860: @item C-x r t @var{string} @key{RET}
  861: @c Insert @var{string} on each line of the region-rectangle
  862: @c (@code{string-rectangle}).
  863: 指定した矩形領域の各行に@var{string}を挿入する
  864: (@code{string-rectangle})。
  865: @end table
  867: @c   The rectangle operations fall into two classes: commands deleting and
  868: @c inserting rectangles, and commands for blank rectangles.
  869: 矩形操作は2種類に分類できます。
  870: 矩形領域を削除したり挿入したりするコマンドと、
  871: 空白の矩形領域を扱うコマンドです。
  873: @kindex C-x r k
  874: @kindex C-x r d
  875: @findex kill-rectangle
  876: @findex delete-rectangle
  877: @c   There are two ways to get rid of the text in a rectangle: you can
  878: @c discard the text (delete it) or save it as the ``last killed''
  879: @c rectangle.  The commands for these two ways are @kbd{C-x r d}
  880: @c (@code{delete-rectangle}) and @kbd{C-x r k} (@code{kill-rectangle}).  In
  881: @c either case, the portion of each line that falls inside the rectangle's
  882: @c boundaries is deleted, causing following text (if any) on the line to
  883: @c move left into the gap.
  884: 矩形領域内のテキストを消すには、2つの方法があります。
  885: テキストを捨てる(削除する)か、
  886: 『最後にキルした』矩形領域として保存するかです。
  887: これらの機能を実現するコマンドは、@kbd{C-x r d}(@code{delete-rectangle})と
  888: @kbd{C-x r k}(@code{kill-rectangle})です。
  889: どちらも、矩形領域の内側にある各行の部分を削除し、
  890: それより右側にテキストがあれば、
  891: 隙間を埋めるようにそれらを左へ移動します。
  893: @c   Note that ``killing'' a rectangle is not killing in the usual sense; the
  894: @c rectangle is not stored in the kill ring, but in a special place that
  895: @c can only record the most recent rectangle killed.  This is because yanking
  896: @c a rectangle is so different from yanking linear text that different yank
  897: @c commands have to be used and yank-popping is hard to make sense of.
  898: 矩形領域の『キル』は普通の意味でのキルではない、
  899: ということに注意してください。
  900: 矩形領域はキルリングには保存されませんが、
  901: 最後にキルした矩形領域を1つだけ記録できる特別な場所に保存されます。
  902: というのは、矩形領域をヤンクすることは、
  903: 線形のテキストのヤンクとは大きく異なり、
  904: 特別なヤンクコマンドが必要だったり、
  905: ヤンクしたテキストの入れ換え操作が意味をなさなかったりするからです。
  907: @kindex C-x r y
  908: @findex yank-rectangle
  909: @c   To yank the last killed rectangle, type @kbd{C-x r y}
  910: @c (@code{yank-rectangle}).  Yanking a rectangle is the opposite of killing
  911: @c one.  Point specifies where to put the rectangle's upper left corner.
  912: @c The rectangle's first line is inserted there, the rectangle's second
  913: @c line is inserted at a position one line vertically down, and so on.  The
  914: @c number of lines affected is determined by the height of the saved
  915: @c rectangle.
  916: 最後にキルした矩形領域をヤンクするには、
  917: @kbd{C-x r y}(@code{yank-rectangle})と打ちます。
  918: 矩形領域のヤンクは矩形領域のキルの逆です。
  919: ポイントは矩形領域の左上隅の位置を指定します。
  920: その場所には矩形領域の1行目が挿入され、
  921: 矩形領域の2行目はそのつぎの行にというように挿入されます。
  922: 影響される行数は、保存されている矩形領域の高さで決まります。
  924: @c   You can convert single-column lists into double-column lists using
  925: @c rectangle killing and yanking; kill the second half of the list as a
  926: @c rectangle and then yank it beside the first line of the list.
  927: @c @xref{Two-Column}, for another way to edit multi-column text.
  928: 矩形領域のキルとヤンクを使うと、1段組みの一覧表を2段組の一覧表に変換できます。
  929: 一覧表の後半を矩形領域としてキルして、
  930: 一覧表の第1行の隣にヤンクすればよいのです。
  932: @c   You can also copy rectangles into and out of registers with @kbd{C-x r
  933: @c r @var{r}} and @kbd{C-x r i @var{r}}.  @xref{RegRect,,Rectangle
  934: @c Registers}.
  935: また、@kbd{C-x r r @var{r}}や@kbd{C-x r i @var{r}}を使えば、
  936: 矩形領域をレジスタにコピーしたり、レジスタから矩形領域をコピーしたりできます。
  937: @xref{RegRect,,Rectangle Registers}。
  939: @kindex C-x r o
  940: @findex open-rectangle
  941: @findex clear-rectangle
  942: @c   There are two commands you can use for making blank rectangles:
  943: @c @kbd{M-x clear-rectangle} which blanks out existing text, and @kbd{C-x r
  944: @c o} (@code{open-rectangle}) which inserts a blank rectangle.  Clearing a
  945: @c rectangle is equivalent to deleting it and then inserting a blank
  946: @c rectangle of the same size.
  947: 空白の矩形領域を作るコマンドは2つあります。
  948: @kbd{M-x clear-rectangle}は既存のテキストを空白で置き換え、
  949: @kbd{C-x r o}(@code{open-rectangle})は空白の矩形領域を挿入します。
  950: 矩形領域をクリアすることは、
  951: 矩形領域を削除してから同じ大きさの空白の矩形領域を挿入するのと同じことです。
  953: @findex delete-whitespace-rectangle
  954: @c   The command @kbd{M-x delete-whitespace-rectangle} deletes horizontal
  955: @c whitespace starting from a particular column.  This applies to each of
  956: @c the lines in the rectangle, and the column is specified by the left
  957: @c edge of the rectangle.  The right edge of the rectangle does not make
  958: @c any difference to this command.
  959: コマンド@kbd{M-x delete-whitespace-rectangle}は、
  960: 特定の桁位置から始まる横に並んだ白文字を削除します。
  961: 矩形領域内の各行に作用し、桁位置は矩形領域の左端です。
  962: 矩形領域の右端はこのコマンドには関係ありません。
  964: @kindex C-x r t
  965: @findex string-rectangle
  966: @c   The command @kbd{C-x r t} (@code{M-x string-rectangle}) replaces the
  967: @c rectangle with a specified string (inserted once on each line).  The
  968: @c string's width need not be the same as the width of the rectangle.  If
  969: @c the string's width is less, the text after the rectangle shifts left; if
  970: @c the string is wider than the rectangle, the text after the rectangle
  971: @c shifts right.
  972: コマンド@kbd{C-x r t}(@kbd{M-x string-rectangle})は、
  973: 矩形領域を指定した文字列で置き換えます。
  974: 文字列の幅は、矩形領域の幅と同じである必要はありません。
  975: 文字列の幅が足りなければ、矩形領域の右側にあるテキストは左へ移動します。
  976: 文字列の幅が広ければ、矩形領域の右側にあるテキストは右へ移動します。

FreeBSD-CVSweb <>