File:  [Local Repository] / gnujdoc / emacs-20.6 / search-ja.texi
Revision 1.1: download - view: text, annotated - select for diffs
Wed Apr 26 06:42:34 2000 UTC (20 years, 6 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 =============================================================
    6: @c This is part of the Emacs manual.
    7: @c Copyright (C) 1985, 86, 87, 93, 94, 95, 1997 Free Software Foundation, Inc.
    8: @c See file emacs.texi for copying conditions.
    9: @node Search, Fixit, Display, Top
   10: @c @chapter Searching and Replacement
   11: @chapter 探索と置換
   12: @c @cindex searching
   13: @c @cindex finding strings within text
   14: @cindex 探索
   15: @cindex テキスト内での文字列探索
   16: 
   17: @c   Like other editors, Emacs has commands for searching for occurrences of
   18: @c a string.  The principal search command is unusual in that it is
   19: @c @dfn{incremental}; it begins to search before you have finished typing the
   20: @c search string.  There are also nonincremental search commands more like
   21: @c those of other editors.
   22: 他のエディタと同様に、Emacsにも文字列を探索するコマンドがあります。
   23: 主な探索コマンドが@dfn{インクリメンタル}(incremental)であるという点で、
   24: 普通とは違います。
   25: 探索したい文字列全体を入力し終えなくても、探索を始めます。
   26: 他のエディタの探索コマンドのように、
   27: インクリメンタルでない探索コマンドもあります。
   28: 
   29: @c   Besides the usual @code{replace-string} command that finds all
   30: @c occurrences of one string and replaces them with another, Emacs has a fancy
   31: @c replacement command called @code{query-replace} which asks interactively
   32: @c which occurrences to replace.
   33: 指定した文字列の出現すべてを探し出して別の文字列に置換する、
   34: 普通の置換コマンド@code{replace-string}に加えて、
   35: Emacsにはより高級な、
   36: 出現箇所をみつけるたびに置換するかどうか対話的に尋ねる
   37: 問い合わせ型置換コマンド@code{query-replace}もあります。
   38: 
   39: @menu
   40: * Incremental Search::	   Search happens as you type the string.
   41: * Nonincremental Search::  Specify entire string and then search.
   42: * Word Search::		   Search for sequence of words.
   43: * Regexp Search::	   Search for match for a regexp.
   44: * Regexps::		   Syntax of regular expressions.
   45: * Search Case::		   To ignore case while searching, or not.
   46: * Replace::		   Search, and replace some or all matches.
   47: * Other Repeating Search:: Operating on all matches for some regexp.
   48: @end menu
   49: 
   50: @node Incremental Search, Nonincremental Search, Search, Search
   51: @c @section Incremental Search
   52: @section インクリメンタルサーチ
   53: 
   54: @c @cindex incremental search
   55: @cindex インクリメンタルサーチ
   56: @c   An incremental search begins searching as soon as you type the first
   57: @c character of the search string.  As you type in the search string, Emacs
   58: @c shows you where the string (as you have typed it so far) would be
   59: @c found.  When you have typed enough characters to identify the place you
   60: @c want, you can stop.  Depending on what you plan to do next, you may or
   61: @c may not need to terminate the search explicitly with @key{RET}.
   62: インクリメンタルサーチでは、
   63: 探索文字列の最初の文字を打つとただちに探索を開始します。
   64: 探索文字列を入力するたびに、
   65: Emacsは(それまでに入力した)文字列がどこでみつかるか表示します。
   66: 目的の箇所を特定するのに十分なだけの文字を打ってしまえば、
   67: そこで終りにできます。
   68: つぎに何をするかにもよりますが、
   69: @key{RET}で探索を陽に終了する必要がある場合もあります。
   70: 
   71: @c WideCommands
   72: @table @kbd
   73: @item C-s
   74: @c Incremental search forward (@code{isearch-forward}).
   75: 前向きにインクリメンタルサーチする(@code{isearch-forward})。
   76: @item C-r
   77: @c Incremental search backward (@code{isearch-backward}).
   78: 後向きにインクリメンタルサーチする(@code{isearch-backward})。
   79: @end table
   80: 
   81: @kindex C-s
   82: @findex isearch-forward
   83: @c   @kbd{C-s} starts an incremental search.  @kbd{C-s} reads characters from
   84: @c the keyboard and positions the cursor at the first occurrence of the
   85: @c characters that you have typed.  If you type @kbd{C-s} and then @kbd{F},
   86: @c the cursor moves right after the first @samp{F}.  Type an @kbd{O}, and see
   87: @c the cursor move to after the first @samp{FO}.  After another @kbd{O}, the
   88: @c cursor is after the first @samp{FOO} after the place where you started the
   89: @c search.  At each step, the buffer text that matches the search string is
   90: @c highlighted, if the terminal can do that; at each step, the current search
   91: @c string is updated in the echo area.
   92: @kbd{C-s}はインクリメンタルサーチを始めます。
   93: @kbd{C-s}はキーボードから文字を読み取り、
   94: 打った文字が最初に現れる位置までカーソルを移動します。
   95: たとえば、@kbd{C-s}に続けて@kbd{F}を打つと、
   96: カーソルは最初に現れる@samp{F}の直後に移動します。
   97: さらに@kbd{O}を打つと、カーソルは最初に現れる@samp{FO}の直後に移動します。
   98: さらに@kbd{O}を打つと、探索を開始した場所以降で最初に現れる
   99: @samp{FOO}の直後にカーソルが移動します。
  100: 各段階において、反転表示できる端末では、
  101: 探索文字列に一致するバッファ内のテキストを強調表示します。
  102: また、各段階において、エコー領域に表示した現在の探索文字列も更新します。
  103: 
  104: @c   If you make a mistake in typing the search string, you can cancel
  105: @c characters with @key{DEL}.  Each @key{DEL} cancels the last character of
  106: @c search string.  This does not happen until Emacs is ready to read another
  107: @c input character; first it must either find, or fail to find, the character
  108: @c you want to erase.  If you do not want to wait for this to happen, use
  109: @c @kbd{C-g} as described below.
  110: 探索する文字列を打ちまちがえたときには、@key{DEL}で取り消せます。
  111: @key{DEL}を1回押すごとに、探索文字列の最後の文字を取り消していきます。
  112: ただし、Emacsがつぎの入力文字を受け付け可能になるまで、
  113: この取り消し操作は実行できません。
  114: つまり、取り消そうと思っている文字をみつけるか、
  115: もしくはみつけられなかったことが確定する必要があります。
  116: それまで待てないなら、以下に説明するように@kbd{C-g}を使ってください。
  117: 
  118: @c   When you are satisfied with the place you have reached, you can type
  119: @c @key{RET}, which stops searching, leaving the cursor where the search
  120: @c brought it.  Also, any command not specially meaningful in searches
  121: @c stops the searching and is then executed.  Thus, typing @kbd{C-a} would
  122: @c exit the search and then move to the beginning of the line.  @key{RET}
  123: @c is necessary only if the next command you want to type is a printing
  124: @c character, @key{DEL}, @key{RET}, or another control character that is
  125: @c special within searches (@kbd{C-q}, @kbd{C-w}, @kbd{C-r}, @kbd{C-s},
  126: @c @kbd{C-y}, @kbd{M-y}, @kbd{M-r}, or @kbd{M-s}).
  127: 目的の箇所まで移動できたら、@key{RET}を打ちます。
  128: すると、探索を終了しカーソルはその箇所に留まります。
  129: また、探索に関係ないコマンドを打っても、
  130: 探索を終了し、そのコマンドを実行します。
  131: したがって、@kbd{C-a}と打てば、探索を終了し、カーソルを行頭に移動します。
  132: @key{RET}が必要な場面は、
  133: つぎに入力したいコマンドが、印字文字、@key{DEL}、@key{RET}、および、
  134: 探索で特別な意味を持つその他の各種コントロール文字
  135: (@kbd{C-q}、@kbd{C-w}、@kbd{C-r}、@kbd{C-s}、
  136: @kbd{C-y}、@kbd{M-y}、@kbd{M-r}、@kbd{M-s})である場合だけです。
  137: 
  138: @c   Sometimes you search for @samp{FOO} and find it, but not the one you
  139: @c expected to find.  There was a second @samp{FOO} that you forgot about,
  140: @c before the one you were aiming for.  In this event, type another @kbd{C-s}
  141: @c to move to the next occurrence of the search string.  This can be done any
  142: @c number of times.  If you overshoot, you can cancel some @kbd{C-s}
  143: @c characters with @key{DEL}.
  144: @samp{FOO}を探してそれがみつかった場合でも、
  145: 予期していた@samp{FOO}ではないこともあるでしょう。
  146: 最初の@samp{FOO}以降に、2つめの@samp{FOO}があることを
  147: 忘れていたような場合です。
  148: このようなときには、さらに@kbd{C-s}を打てば、
  149: 探索文字列のつぎの出現箇所に移動できます。
  150: この操作は何度でも繰り返せます。
  151: 行き過ぎてしまったときには、@key{DEL}で@kbd{C-s}の操作を取り消せます。
  152: 
  153: @c   After you exit a search, you can search for the same string again by
  154: @c typing just @kbd{C-s C-s}: the first @kbd{C-s} is the key that invokes
  155: @c incremental search, and the second @kbd{C-s} means ``search again.''
  156: 探索を終了したあとでも、単に@kbd{C-s C-s}と打てば、
  157: ふたたび同じ文字列を探索できます。
  158: つまり、最初の@kbd{C-s}がインクリメンタルサーチを起動して、
  159: つぎの@kbd{C-s}が『再探索』を意味します。
  160: 
  161: @c   To reuse earlier search strings, use the @dfn{search ring}.  The
  162: @c commands @kbd{M-p} and @kbd{M-n} move through the ring to pick a search
  163: @c string to reuse.  These commands leave the selected search ring element
  164: @c in the minibuffer, where you can edit it.  Type @kbd{C-s} or @kbd{C-r}
  165: @c to terminate editing the string and search for it.
  166: 以前に探索した文字列を再利用するには、
  167: @dfn{探索リング}(search ring)を使います。
  168: コマンド@kbd{M-p}と@kbd{M-n}でリング内を移動して、
  169: 再利用する文字列を取り出します。
  170: これらのコマンドは、探索リング内の選択した要素をミニバッファに置きますから、
  171: 編集することも可能です。
  172: @kbd{C-s}や@kbd{C-r}を打てば、
  173: 文字列の編集を終了して探索を開始できます。
  174: 
  175: @c   If your string is not found at all, the echo area says @samp{Failing
  176: @c I-Search}.  The cursor is after the place where Emacs found as much of your
  177: @c string as it could.  Thus, if you search for @samp{FOOT}, and there is no
  178: @c @samp{FOOT}, you might see the cursor after the @samp{FOO} in @samp{FOOL}.
  179: @c At this point there are several things you can do.  If your string was
  180: @c mistyped, you can rub some of it out and correct it.  If you like the place
  181: @c you have found, you can type @key{RET} or some other Emacs command to
  182: @c ``accept what the search offered.''  Or you can type @kbd{C-g}, which
  183: @c removes from the search string the characters that could not be found (the
  184: @c @samp{T} in @samp{FOOT}), leaving those that were found (the @samp{FOO} in
  185: @c @samp{FOOT}).  A second @kbd{C-g} at that point cancels the search
  186: @c entirely, returning point to where it was when the search started.
  187: 探している文字列がまったくみつからなかった場合には、
  188: エコー領域に@samp{Failing I-Search}と表示されます。
  189: カーソルは、指定した文字列に可能な限り一致する箇所の直後にあります。
  190: たとえば、@samp{FOOT}を探索しようとしたのに@samp{FOOT}がなければ、
  191: カーソルは@samp{FOOL}の@samp{FOO}の直後にあります。
  192: この時点でできることはいくつかあります。
  193: 文字列を打ちまちがえたのならば、それを消去して訂正します。
  194: その箇所でよいのなら、『探索したものを受理する』ために、
  195: @key{RET}か他のEmacsコマンドを打ちます。
  196: あるいは、@kbd{C-g}を打てば、
  197: 探索文字列からみつけられなかった文字(@samp{FOOT}中の@samp{T})を取り除き、
  198: みつけた文字列(@samp{FOOT}中の@samp{FOO})は
  199: そのままにしておくこともできます。
  200: ここで、さらに@kbd{C-g}を打つと、
  201: 探索全体を取り止めて、探索を開始した位置に戻ります。
  202: 
  203: @c   An upper-case letter in the search string makes the search
  204: @c case-sensitive.  If you delete the upper-case character from the search
  205: @c string, it ceases to have this effect.  @xref{Search Case}.
  206: 探索文字列に大文字を指定すると、
  207: 大文字小文字を区別(case-sensitive)して探索します。
  208: 探索文字列から大文字を削除すると、この効果は消えます。
  209: @xref{Search Case}。
  210: 
  211: @c   If a search is failing and you ask to repeat it by typing another
  212: @c @kbd{C-s}, it starts again from the beginning of the buffer.  Repeating
  213: @c a failing reverse search with @kbd{C-r} starts again from the end.  This
  214: @c is called @dfn{wrapping around}.  @samp{Wrapped} appears in the search
  215: @c prompt once this has happened.  If you keep on going past the original
  216: @c starting point of the search, it changes to @samp{Overwrapped}, which
  217: @c means that you are revisiting matches that you have already seen.
  218: 探索に失敗したときに、さらに@kbd{C-s}を打って探索の続行を指示すると、
  219: バッファの先頭からもう一度探索し始めます。
  220: 後向きの探索に失敗したときに再度@kbd{C-r}を打つと、
  221: バッファの末尾から探索を再開します。
  222: これらの操作は@dfn{巻き直し}(wrapping around)と呼ばれます。
  223: 巻き直しが起こると、探索のプロンプトには@samp{Wrapped}が表示されます。
  224: もともとの探索開始位置を通過してなお探索を続けると、
  225: 表示が@samp{Overwrapped}に変わります。
  226: これは、探索文字列にすでに一度一致した箇所を
  227: 再度探索していることを意味します。
  228: 
  229: @c @cindex quitting (in search)
  230: @cindex 中断(探索)
  231: @c   The @kbd{C-g} ``quit'' character does special things during searches;
  232: @c just what it does depends on the status of the search.  If the search has
  233: @c found what you specified and is waiting for input, @kbd{C-g} cancels the
  234: @c entire search.  The cursor moves back to where you started the search.  If
  235: @c @kbd{C-g} is typed when there are characters in the search string that have
  236: @c not been found---because Emacs is still searching for them, or because it
  237: @c has failed to find them---then the search string characters which have not
  238: @c been found are discarded from the search string.  With them gone, the
  239: @c search is now successful and waiting for more input, so a second @kbd{C-g}
  240: @c will cancel the entire search.
  241: 『中断』文字@kbd{C-g}は、探索中には特別な意味があり、
  242: その機能は探索の状態に依存します。
  243: 指定したものがみつかり入力待ちの状態にあると、
  244: @kbd{C-g}は探索全体を取り消します。
  245: カーソルは探索開始位置に戻ります。
  246: Emacsが探索中であったり探索に失敗したために、
  247: 探索文字列内に未発見の文字がある場合に@kbd{C-g}を打つと、
  248: 探索文字列から未発見の文字を消去します。
  249: そうすると、これで探索が成功したことになるので、
  250: 入力待ちになります。
  251: 続けて@kbd{C-g}を打つと、探索全体を取り消します。
  252: 
  253: @c   To search for a newline, type @kbd{C-j}.  To search for another
  254: @c control character, such as control-S or carriage return, you must quote
  255: @c it by typing @kbd{C-q} first.  This function of @kbd{C-q} is analogous
  256: @c to its use for insertion (@pxref{Inserting Text}): it causes the
  257: @c following character to be treated the way any ``ordinary'' character is
  258: @c treated in the same context.  You can also specify a character by its
  259: @c octal code: enter @kbd{C-q} followed by a sequence of octal digits.
  260: 改行を探索するには、@kbd{C-j}を打ちます。
  261: コントロールSや改行などのコントロール文字を探索するには、
  262: まず@kbd{C-q}を打ってクォートする必要があります。
  263: @kbd{C-q}のこの機能は、挿入時の利用法に似ています
  264: (@pxref{Inserting Text})。
  265: このコマンドは、あとに続く文字を、
  266: 同じ文脈における『普通の』文字と同様に扱うようにします。
  267: 文字を8進コードで指定することもできて、
  268: @kbd{C-q}に続けて8進数字列を入力します。
  269: 
  270: @c   You can change to searching backwards with @kbd{C-r}.  If a search fails
  271: @c because the place you started was too late in the file, you should do this.
  272: @c Repeated @kbd{C-r} keeps looking for more occurrences backwards.  A
  273: @c @kbd{C-s} starts going forwards again.  @kbd{C-r} in a search can be canceled
  274: @c with @key{DEL}.
  275: @kbd{C-r}を使えば、後向き探索に変更できます。
  276: ファイルのうしろのほうで探索し始めたために探索に失敗したのであれば、
  277: これを試してください。
  278: @kbd{C-r}を繰り返し打つと、後向きにさらに探索を続けます。
  279: @kbd{C-s}は、ふたたび前向き探索を再開します。
  280: 探索中の@kbd{C-r}は@key{DEL}で取り消せます。
  281: 
  282: @kindex C-r
  283: @findex isearch-backward
  284: @c   If you know initially that you want to search backwards, you can use
  285: @c @kbd{C-r} instead of @kbd{C-s} to start the search, because @kbd{C-r} as
  286: @c a key runs a command (@code{isearch-backward}) to search backward.  A
  287: @c backward search finds matches that are entirely before the starting
  288: @c point, just as a forward search finds matches that begin after it.
  289: 始めから後向きで探索するのであれば、
  290: @kbd{C-s}のかわりに@kbd{C-r}を使って探索を始めます。
  291: @kbd{C-r}は、後向きに探索するコマンド@code{isearch-backward}を起動します。
  292: 前向き探索が開始位置よりうしろにある一致箇所をみつけるのと同様に、
  293: 後向き探索は開始位置よりまえにある一致箇所をみつけだします。
  294: 
  295: @c   The characters @kbd{C-y} and @kbd{C-w} can be used in incremental
  296: @c search to grab text from the buffer into the search string.  This makes
  297: @c it convenient to search for another occurrence of text at point.
  298: @c @kbd{C-w} copies the word after point as part of the search string,
  299: @c advancing point over that word.  Another @kbd{C-s} to repeat the search
  300: @c will then search for a string including that word.  @kbd{C-y} is similar
  301: @c to @kbd{C-w} but copies all the rest of the current line into the search
  302: @c string.  Both @kbd{C-y} and @kbd{C-w} convert the text they copy to
  303: @c lower case if the search is currently not case-sensitive; this is so the
  304: @c search remains case-insensitive.
  305: インクリメンタルサーチ中には、文字@kbd{C-y}と@kbd{C-w}を使って、
  306: バッファから探索文字列へテキストを取り込むことができます。
  307: この機能は、ポイント位置にあるテキストの出現箇所を探すときに便利です。
  308: @kbd{C-w}は、ポイント以降の単語を探索文字列の一部としてコピーし、
  309: ポイントをその単語の末尾に進めます。
  310: 探索を繰り返す意味で@kbd{C-s}を打つと、
  311: その単語を含んだ文字列を探索します。
  312: @kbd{C-y}も@kbd{C-w}に似ていますが、
  313: 現在行の残りの部分をすべて探索文字列にコピーします。
  314: 大文字小文字を区別しない探索では、
  315: @kbd{C-y}と@kbd{C-w}はともに、
  316: コピーするテキストを小文字だけに変換します。
  317: 
  318: @c   The character @kbd{M-y} copies text from the kill ring into the search
  319: @c string.  It uses the same text that @kbd{C-y} as a command would yank.
  320: @c @xref{Yanking}.
  321: 文字@kbd{M-y}は、キルリングから探索文字列にテキストをコピーします。
  322: これには、ヤンクコマンド@kbd{C-y}がヤンクするのと
  323: 同じテキストを用います。
  324: @xref{Yanking}。
  325: 
  326: @c   When you exit the incremental search, it sets the mark to where point
  327: @c @emph{was}, before the search.  That is convenient for moving back
  328: @c there.  In Transient Mark mode, incremental search sets the mark without
  329: @c activating it, and does so only if the mark is not already active.
  330: インクリメンタルサーチを終了すると、
  331: 探索開始前にポイントが@emph{あった}位置にマークを置きます。
  332: これにより容易にその位置に戻れます。
  333: 暫定マーク(transient-mark)モードでは、
  334: マークが不活性のときに限って、
  335: インクリメンタルサーチが設定するマークも不活性です。
  336: 
  337: @vindex isearch-mode-map
  338: @c   To customize the special characters that incremental search understands,
  339: @c alter their bindings in the keymap @code{isearch-mode-map}.  For a list
  340: @c of bindings, look at the documentation of @code{isearch-mode} with
  341: @c @kbd{C-h f isearch-mode @key{RET}}.
  342: インクリメンタルサーチ中に用いる特別な文字をカスタマイズするには、
  343: キーマップ@code{isearch-mode-map}中のバインディングを変更します。
  344: バインディング一覧は、@kbd{C-h f isearch-mode @key{RET}}を使って
  345: @code{isearch-mode}に関する説明文を参照してください。
  346: 
  347: @c @subsection Slow Terminal Incremental Search
  348: @subsection 低速端末でのインクリメンタルサーチ
  349: 
  350: @c   Incremental search on a slow terminal uses a modified style of display
  351: @c that is designed to take less time.  Instead of redisplaying the buffer at
  352: @c each place the search gets to, it creates a new single-line window and uses
  353: @c that to display the line that the search has found.  The single-line window
  354: @c comes into play as soon as point gets outside of the text that is already
  355: @c on the screen.
  356: 速度の遅い端末でのインクリメンタルサーチでは、
  357: 表示時間が少なくてすむように設計された表示形式を使います。
  358: みつけた箇所でバッファを再表示するかわりに、
  359: 新たに1行分のウィンドウを作ってそこにみつけた行を表示します。
  360: この1行分のウィンドウは、
  361: 探索することでポイントが画面に表示中のテキストから
  362: 飛び出た時点で使われます。
  363: 
  364: @c   When you terminate the search, the single-line window is removed.
  365: @c Then Emacs redisplays the window in which the search was done, to show
  366: @c its new position of point.
  367: 探索を終了すると、この1行分のウィンドウは消えます。
  368: そして、Emacsは探索を完了したウィンドウを再表示して、
  369: 新たなポイント位置を示します。
  370: 
  371: @ignore
  372: @c   The three dots at the end of the search string, normally used to indicate
  373: @c that searching is going on, are not displayed in slow style display.
  374: 探索中であることを示すために探索文字列の末尾に3つの点
  375: (@dots{})を通常表示しますが、低速向けの表示形式では表示しません。
  376: @end ignore
  377: 
  378: @vindex search-slow-speed
  379: @c   The slow terminal style of display is used when the terminal baud rate is
  380: @c less than or equal to the value of the variable @code{search-slow-speed},
  381: @c initially 1200.
  382: 低速向けの表示形式を使うのは、
  383: 端末のボーレートが変数@code{search-slow-speed}の値以下である場合で、
  384: その初期値は1200です。
  385: 
  386: @vindex search-slow-window-lines
  387: @c   The number of lines to use in slow terminal search display is controlled
  388: @c by the variable @code{search-slow-window-lines}.  Its normal value is 1.
  389: 低速向けの表示形式に使う表示用ウィンドウの行数は、
  390: 変数@code{search-slow-window-lines}で制御します。
  391: 通常の値は1です。
  392: 
  393: @node Nonincremental Search, Word Search, Incremental Search, Search
  394: @c @section Nonincremental Search
  395: @section 一括型探索
  396: @c @cindex nonincremental search
  397: @cindex 一括型探索
  398: 
  399: @c   Emacs also has conventional nonincremental search commands, which require
  400: @c you to type the entire search string before searching begins.
  401: Emacsでは、従来方式の一括型探索コマンドもあります。
  402: 探索を開始するまえに探索文字列全体を打っておく必要があります。
  403: 
  404: @table @kbd
  405: @item C-s @key{RET} @var{string} @key{RET}
  406: @c Search for @var{string}.
  407: @var{string}を探索する。
  408: @item C-r @key{RET} @var{string} @key{RET}
  409: @c Search backward for @var{string}.
  410: @var{string}を後向きに探索する。
  411: @end table
  412: 
  413: @c   To do a nonincremental search, first type @kbd{C-s @key{RET}}.  This
  414: @c enters the minibuffer to read the search string; terminate the string
  415: @c with @key{RET}, and then the search takes place.  If the string is not
  416: @c found, the search command gets an error.
  417: 一括型探索を実行するには、まず@kbd{C-s @key{RET}}と打ちます。
  418: すると、探索文字列を読み取るためにミニバッファに移動します。
  419: 文字列を@key{RET}で終えると、探索を開始します。
  420: 文字列がみつからなければ、探索コマンドはエラーになります。
  421: 
  422: @c   The way @kbd{C-s @key{RET}} works is that the @kbd{C-s} invokes
  423: @c incremental search, which is specially programmed to invoke nonincremental
  424: @c search if the argument you give it is empty.  (Such an empty argument would
  425: @c otherwise be useless.)  @kbd{C-r @key{RET}} also works this way.
  426: @kbd{C-s @key{RET}}はつぎのように動作します。
  427: まず、@kbd{C-s}がインクリメンタルサーチを起動します。
  428: インクリメンタルサーチは、特別な場合として、
  429: 引数が空であったときには一括型探索を起動するようにプログラムしてあります。
  430: (さもなければ、そのような空の引数に意味はない。)
  431:  @kbd{C-r @key{RET}}もこのように動作します。
  432: 
  433: @c   However, nonincremental searches performed using @kbd{C-s @key{RET}} do
  434: @c not call @code{search-forward} right away.  The first thing done is to see
  435: @c if the next character is @kbd{C-w}, which requests a word search.
  436: しかし、@kbd{C-s @key{RET}}で実行される一括型探索は、
  437: @code{search-forward}をただちに呼び出すわけではありません。
  438: まず、つぎの文字が単語探索を指示する@kbd{C-w}であるかどうか調べます。
  439: @ifinfo
  440: @c @xref{Word Search}.
  441: @xref{Word Search}。
  442: @end ifinfo
  443: 
  444: @findex search-forward
  445: @findex search-backward
  446: @c   Forward and backward nonincremental searches are implemented by the
  447: @c commands @code{search-forward} and @code{search-backward}.  These
  448: @c commands may be bound to keys in the usual manner.  The feature that you
  449: @c can get to them via the incremental search commands exists for
  450: @c historical reasons, and to avoid the need to find suitable key sequences
  451: @c for them.
  452: 前向き/後向きの一括型探索は、
  453: コマンド@code{search-forward}と@code{search-backward}で実装されています。
  454: これらのコマンドは通常と同じようにキーにバインドできます。
  455: インクリメンタルサーチコマンドから呼び出せるようになっているのは、
  456: 歴史的な理由、および、
  457: これらの機能にふさわしいキー列を選ぶ労力を削減できるという理由からです。
  458: 
  459: @node Word Search, Regexp Search, Nonincremental Search, Search
  460: @c @section Word Search
  461: @section 単語探索
  462: @c @cindex word search
  463: @cindex 単語探索
  464: 
  465: @c   Word search searches for a sequence of words without regard to how the
  466: @c words are separated.  More precisely, you type a string of many words,
  467: @c using single spaces to separate them, and the string can be found even if
  468: @c there are multiple spaces, newlines or other punctuation between the words.
  469: 単語探索は、単語の区切られ方を無視して、単語の列を探索します。
  470: より正確には、空白1個で区切った数個の単語を打ち込むと、
  471: 単語と単語のあいだに複数個の空白/改行/句読点があったとしても、
  472: それらの文字列をみつけだすことができます。
  473: 
  474: @c   Word search is useful for editing a printed document made with a text
  475: @c formatter.  If you edit while looking at the printed, formatted version,
  476: @c you can't tell where the line breaks are in the source file.  With word
  477: @c search, you can search without having to know them.
  478: 単語探索は、テキスト清書系で整形済みの文書を編集する場合に便利です。
  479: 整形した印刷出力を見ながら編集する場合、
  480: ソースファイルのどこで行が区切られているのかわかりません。
  481: 単語探索を使えば、単語の区切られ方を知らなくても探索できます。
  482: 
  483: @table @kbd
  484: @item C-s @key{RET} C-w @var{words} @key{RET}
  485: @c Search for @var{words}, ignoring details of punctuation.
  486: 句読点などの詳細は無視して、@var{words}を探索する。
  487: @item C-r @key{RET} C-w @var{words} @key{RET}
  488: @c Search backward for @var{words}, ignoring details of punctuation.
  489: 句読点などの詳細は無視して、後向きに@var{words}を探索する。
  490: @end table
  491: 
  492: @c   Word search is a special case of nonincremental search and is invoked
  493: @c with @kbd{C-s @key{RET} C-w}.  This is followed by the search string,
  494: @c which must always be terminated with @key{RET}.  Being nonincremental,
  495: @c this search does not start until the argument is terminated.  It works
  496: @c by constructing a regular expression and searching for that; see
  497: @c @ref{Regexp Search}.
  498: 単語探索は、一括型探索の特別な場合であって、
  499: @kbd{C-s @key{RET} C-w}で起動します。
  500: この入力に続いて、探索文字列を入力し、
  501: 文字列はつねに@key{RET}で終えます。
  502: 一括型であるため、単語探索も引数を入力し終えるまで探索を開始しません。
  503: 単語探索は、正規表現を構築し、その正規表現で探索を行うことで
  504: 動作します。
  505: @xref{Regexp Search}。
  506: 
  507: @c   Use @kbd{C-r @key{RET} C-w} to do backward word search.
  508: 後向きの単語探索には@kbd{C-r @key{RET} C-w}を使います。
  509: 
  510: @findex word-search-forward
  511: @findex word-search-backward
  512: @c   Forward and backward word searches are implemented by the commands
  513: @c @code{word-search-forward} and @code{word-search-backward}.  These
  514: @c commands may be bound to keys in the usual manner.  The feature that you
  515: @c can get to them via the incremental search commands exists for historical
  516: @c reasons, and to avoid the need to find suitable key sequences for them.
  517: 前向き/後向きの単語探索は、それぞれ、
  518: コマンド@code{word-search-forward}と@code{word-search-backward}で
  519: 実装されています。
  520: これらのコマンドは通常どおりキーに割り当てることができます。
  521: インクリメンタルサーチコマンドから呼び出せるようになっているのは、
  522: 歴史的な理由、および、
  523: これらの機能にふさわしいキー列を選ぶ労力を削減できるという理由からです。
  524: 
  525: @node Regexp Search, Regexps, Word Search, Search
  526: @c @section Regular Expression Search
  527: @section 正規表現探索
  528: @c @cindex regular expression
  529: @cindex 正規表現
  530: @cindex regexp
  531: 
  532: @c   A @dfn{regular expression} (@dfn{regexp}, for short) is a pattern that
  533: @c denotes a class of alternative strings to match, possibly infinitely
  534: @c many.  In GNU Emacs, you can search for the next match for a regexp
  535: @c either incrementally or not.
  536: @dfn{正規表現}(regular expression、@dfn{regexp}と略す)とは、
  537: 一致する可能性がある一連の(無限個でもよい)文字列を表現するパターンです。
  538: GNU Emacsでは、インクリメンタルサーチでも一括型探索でも、
  539: 正規表現を用いてつぎの一致箇所を探索できます。
  540: 
  541: @kindex C-M-s
  542: @findex isearch-forward-regexp
  543: @kindex C-M-r
  544: @findex isearch-backward-regexp
  545: @c   Incremental search for a regexp is done by typing @kbd{C-M-s}
  546: @c (@code{isearch-forward-regexp}).  This command reads a search string
  547: @c incrementally just like @kbd{C-s}, but it treats the search string as a
  548: @c regexp rather than looking for an exact match against the text in the
  549: @c buffer.  Each time you add text to the search string, you make the
  550: @c regexp longer, and the new regexp is searched for.  Invoking @kbd{C-s}
  551: @c with a prefix argument (its value does not matter) is another way to do
  552: @c a forward incremental regexp search.  To search backward for a regexp,
  553: @c use @kbd{C-M-r} (@code{isearch-backward-regexp}), or @kbd{C-r} with a
  554: @c prefix argument.
  555: 正規表現によるインクリメンタルサーチを実行するには、
  556: @kbd{C-M-s}(@code{isearch-forward-regexp})と打ちます。
  557: このコマンドは、@kbd{C-s}と同様に、探索文字列を逐次読み取ります。
  558: ただし、探索文字列をバッファのテキストに対して正確に照合するため
  559: のものとみなすのではなく、正規表現として扱います。
  560: 探索文字列にテキストを追加するごとに、
  561: 正規表現は長くなり、新たな正規表現を探索します。
  562: (値は関係ない)前置引数を指定して@kbd{C-s}を起動しても、
  563: 前向きに正規表現の探索を始められます。
  564: 後向きに正規表現を探索するには、
  565: @kbd{C-M-r}(@code{isearch-backward-regexp})を使うか、
  566: 前置引数を指定して@kbd{C-r}を使います。
  567: 
  568: @c   All of the control characters that do special things within an
  569: @c ordinary incremental search have the same function in incremental regexp
  570: @c search.  Typing @kbd{C-s} or @kbd{C-r} immediately after starting the
  571: @c search retrieves the last incremental search regexp used; that is to
  572: @c say, incremental regexp and non-regexp searches have independent
  573: @c defaults.  They also have separate search rings that you can access with
  574: @c @kbd{M-p} and @kbd{M-n}.
  575: 通常のインクリメンタルサーチにおいて特別な機能を持つコントロール文字は、
  576: 正規表現のインクリメンタルサーチでも同じ機能を持ちます。
  577: 探索の開始直後に@kbd{C-s}や@kbd{C-r}を打つと、
  578: 最後のインクリメンタルサーチに用いた正規表現を再度使います。
  579: つまり、正規表現を用いる探索とそうでない探索とには、
  580: それぞれ独立のデフォルトがあるのです。
  581: @kbd{M-p}と@kbd{M-n}で参照できる探索リングも
  582: それぞれ別々です。
  583: 
  584: @c   If you type @key{SPC} in incremental regexp search, it matches any
  585: @c sequence of whitespace characters, including newlines.  If you want
  586: @c to match just a space, type @kbd{C-q @key{SPC}}.
  587: 正規表現のインクリメンタルサーチで@key{SPC}を打つと、
  588: 改行を含めた任意個の白文字に一致します。
  589: ちょうど1個の空白に一致させたいのであれば、
  590: @kbd{C-q @key{SPC}}と打ちます。
  591: 
  592: @c   Note that adding characters to the regexp in an incremental regexp
  593: @c search can make the cursor move back and start again.  For example, if
  594: @c you have searched for @samp{foo} and you add @samp{\|bar}, the cursor
  595: @c backs up in case the first @samp{bar} precedes the first @samp{foo}.
  596: 正規表現のインクリメンタルサーチ中に正規表現に文字を加えると、
  597: カーソルをもとに戻して探索し直すことがあります。
  598: たとえば、@samp{foo}を探索し終えたときに@samp{\|bar}を追加したとします。
  599: 最初の@samp{bar}が最初の@samp{foo}に先行する場合には、
  600: カーソルはまえに戻ります。
  601: 
  602: @findex re-search-forward
  603: @findex re-search-backward
  604: @c   Nonincremental search for a regexp is done by the functions
  605: @c @code{re-search-forward} and @code{re-search-backward}.  You can invoke
  606: @c these with @kbd{M-x}, or bind them to keys, or invoke them by way of
  607: @c incremental regexp search with @kbd{C-M-s @key{RET}} and @kbd{C-M-r
  608: @c @key{RET}}.
  609: 正規表現の一括型探索は、関数@code{re-search-forward}と
  610: @code{re-search-backward}で行われます。
  611: これらは、@kbd{M-x}で呼び出したり、キーに割り当てたり、あるいは、
  612: @kbd{C-M-s @key{RET}}や@kbd{C-M-r @key{RET}}として
  613: 正規表現のインクリメンタルサーチの方法で起動したりできます。
  614: 
  615: @c   If you use the incremental regexp search commands with a prefix
  616: @c argument, they perform ordinary string search, like
  617: @c @code{isearch-forward} and @code{isearch-backward}.  @xref{Incremental
  618: @c Search}.
  619: 正規表現のインクリメンタルサーチコマンドに前置引数を指定すると、
  620: @code{isearch-forward}や@code{isearch-backward}のように、
  621: 普通の文字列探索を行います。
  622: @xref{Incremental  Search}。
  623: 
  624: @node Regexps, Search Case, Regexp Search, Search
  625: @c @section Syntax of Regular Expressions
  626: @section 正規表現の構文
  627: @c @cindex regexp syntax
  628: @cindex regexpの構文
  629: 
  630: @c   Regular expressions have a syntax in which a few characters are
  631: @c special constructs and the rest are @dfn{ordinary}.  An ordinary
  632: @c character is a simple regular expression which matches that same
  633: @c character and nothing else.  The special characters are @samp{$},
  634: @c @samp{^}, @samp{.}, @samp{*}, @samp{+}, @samp{?}, @samp{[}, @samp{]} and
  635: @c @samp{\}.  Any other character appearing in a regular expression is
  636: @c ordinary, unless a @samp{\} precedes it.
  637: 正規表現には、特別な使い方をする少数の文字と
  638: その他の@dfn{普通の}文字から成る構文があります。
  639: 普通の文字は、
  640: 同じ文字だけに一致してそれ以外には一致しない単純な正規表現です。
  641: 特別な文字は、@samp{$}、@samp{^}、@samp{.}、@samp{*}、@samp{+}、
  642: @samp{?}、@samp{[}、@samp{]}、および、@samp{\}です。
  643: @samp{\}が先行する場合を除いて、
  644: 正規表現に現れるこれら以外の文字は普通の文字です。
  645: 
  646: @c   For example, @samp{f} is not a special character, so it is ordinary, and
  647: @c therefore @samp{f} is a regular expression that matches the string
  648: @c @samp{f} and no other string.  (It does @emph{not} match the string
  649: @c @samp{ff}.)  Likewise, @samp{o} is a regular expression that matches
  650: @c only @samp{o}.  (When case distinctions are being ignored, these regexps
  651: @c also match @samp{F} and @samp{O}, but we consider this a generalization
  652: @c of ``the same string,'' rather than an exception.)
  653: たとえば、@samp{f}は特別な文字ではなく、通常の文字ですから、
  654: 文字列@samp{f}に一致してそれ以外の文字列には一致しない正規表現です。
  655: (これは、文字列@samp{ff}には一致し@emph{ない}。)
  656: 同様に、@samp{o}は、@samp{o}だけに一致する正規表現です。
  657: (大文字小文字を区別しない場合、
  658: これらの正規表現は@samp{F}や@samp{O}にも一致するが、
  659: これらは例外というよりは、『同じ文字列』の一般化として捉える。)
  660: 
  661: @c   Any two regular expressions @var{a} and @var{b} can be concatenated.  The
  662: @c result is a regular expression which matches a string if @var{a} matches
  663: @c some amount of the beginning of that string and @var{b} matches the rest of
  664: @c the string.@refill
  665: 任意の2つの正規表現@var{a}と@var{b}を連結できます。
  666: その結果は、@var{a}が文字列の始めの適当な部分に一致して、かつ、
  667: @var{b}が文字列の残りの部分に一致する場合に、
  668: 文字列に一致するような正規表現です。
  669: 
  670: @c   As a simple example, we can concatenate the regular expressions @samp{f}
  671: @c and @samp{o} to get the regular expression @samp{fo}, which matches only
  672: @c the string @samp{fo}.  Still trivial.  To do something nontrivial, you
  673: @c need to use one of the special characters.  Here is a list of them.
  674: 簡単な例として、正規表現@samp{f}と@samp{o}を連結すると、
  675: 正規表現@samp{fo}を得ますが、
  676: これは文字列@samp{fo}だけに一致します。
  677: 簡単ですね。
  678: 多少とも複雑なことを行うには、特別な文字を使う必要があります。
  679: 以下にその一覧をあげます。
  680: 
  681: @table @kbd
  682: @c @item .@: @r{(Period)}
  683: @item .@: @r{(ピリオド)}
  684: @c is a special character that matches any single character except a newline.
  685: @c Using concatenation, we can make regular expressions like @samp{a.b}, which
  686: @c matches any three-character string that begins with @samp{a} and ends with
  687: @c @samp{b}.@refill
  688: 特別な文字であり、改行以外の任意の1文字に一致する。
  689: 連結を使って@samp{a.b}のような正規表現を作れる。
  690: これは、@samp{a}で始まり@samp{b}で終る任意の3文字の文字列に一致する。
  691: 
  692: @item *
  693: @c is not a construct by itself; it is a postfix operator that means to
  694: @c match the preceding regular expression repetitively as many times as
  695: @c possible.  Thus, @samp{o*} matches any number of @samp{o}s (including no
  696: @c @samp{o}s).
  697: 単独では構成要素ではない。
  698: 直前の正規表現を可能な限り反復することを意味する後置演算子である。
  699: すなわち、(@samp{o}が存在しない場合も含めて)
  700: @samp{o*}は任意個の@samp{o}に一致する。
  701: 
  702: @c @samp{*} always applies to the @emph{smallest} possible preceding
  703: @c expression.  Thus, @samp{fo*} has a repeating @samp{o}, not a repeating
  704: @c @samp{fo}.  It matches @samp{f}, @samp{fo}, @samp{foo}, and so on.
  705: @samp{*}はつねに先行する@emph{最小}の正規表現に適用される。
  706: したがって、@samp{fo*}は@samp{fo}を繰り返すのではなく、
  707: @samp{o}を繰り返す。
  708: この正規表現は@samp{f}、@samp{fo}、@samp{foo}などに一致する。
  709: 
  710: @c The matcher processes a @samp{*} construct by matching, immediately,
  711: @c as many repetitions as can be found.  Then it continues with the rest
  712: @c of the pattern.  If that fails, backtracking occurs, discarding some
  713: @c of the matches of the @samp{*}-modified construct in case that makes
  714: @c it possible to match the rest of the pattern.  For example, in matching
  715: @c @samp{ca*ar} against the string @samp{caaar}, the @samp{a*} first
  716: @c tries to match all three @samp{a}s; but the rest of the pattern is
  717: @c @samp{ar} and there is only @samp{r} left to match, so this try fails.
  718: @c The next alternative is for @samp{a*} to match only two @samp{a}s.
  719: @c With this choice, the rest of the regexp matches successfully.@refill
  720: @samp{*}を用いた構成は、一致を処理するときには、
  721: ただちに得られる限りの反復回数に展開される。
  722: そうしてから、残りのパターンを処理する。
  723: 一致に失敗すると、バックトラック(後戻り)が発生して、
  724: @samp{*}を用いた構成の反復回数を減らして、
  725: パターンの残りの部分が一致するようにする。
  726: たとえば、文字列@samp{caaar}に対して
  727: @samp{ca*ar}を一致させることを考えてみる。
  728: 始めに、@samp{a*}を3つの@samp{a}すべてに一致させようとする。
  729: しかし、残りのパターンが@samp{ar}なのに@samp{r}しか残っていないため、
  730: この試みは失敗する。
  731: そこで、つぎは@samp{a*}を@samp{a}2つだけに一致させる。
  732: こうすると、残りの正規表現も正しく一致する。
  733: 
  734: @item +
  735: @c is a postfix operator, similar to @samp{*} except that it must match
  736: @c the preceding expression at least once.  So, for example, @samp{ca+r}
  737: @c matches the strings @samp{car} and @samp{caaaar} but not the string
  738: @c @samp{cr}, whereas @samp{ca*r} matches all three strings.
  739: @samp{*}に似た後置演算子だが、
  740: 直前の正規表現に1回以上一致する必要がある。
  741: たとえば、@samp{ca+r}は、文字列@samp{car}や@samp{caaaar}には一致するが、
  742: 文字列@samp{cr}には一致ない。
  743: @samp{ca*r}の場合は、上記の3つすべてに一致する。
  744: 
  745: @item ?
  746: @c is a postfix operator, similar to @samp{*} except that it can match the
  747: @c preceding expression either once or not at all.  For example,
  748: @c @samp{ca?r} matches @samp{car} or @samp{cr}; nothing else.
  749: @samp{*}に似た後置演算子だが、
  750: 直前の正規表現に1回だけ一致するか、あるいは、1回も一致しない。
  751: たとえば、@samp{ca?r}は、@samp{car}や@samp{cr}に一致するが、
  752: 他のものには一致しない。
  753: 
  754: @item [ @dots{} ]
  755: @c is a @dfn{character set}, which begins with @samp{[} and is terminated
  756: @c by @samp{]}.  In the simplest case, the characters between the two
  757: @c brackets are what this set can match.
  758: @samp{[}で始まり@samp{]}で終る@dfn{文字集合}を表す。
  759: もっとも単純な場合は、
  760: この2つの中括弧のあいだにある文字の1つ1つがこの文字集合に一致する。
  761: 
  762: @c Thus, @samp{[ad]} matches either one @samp{a} or one @samp{d}, and
  763: @c @samp{[ad]*} matches any string composed of just @samp{a}s and @samp{d}s
  764: @c (including the empty string), from which it follows that @samp{c[ad]*r}
  765: @c matches @samp{cr}, @samp{car}, @samp{cdr}, @samp{caddaar}, etc.
  766: したがって、@samp{[ad]}は、@samp{a}1文字か@samp{d}1文字のどちらにも一致する。
  767: @samp{[ad]*}は、@samp{a}と@samp{d}だけから成る
  768: (空の文字列を含む)任意の文字列に一致する。
  769: このことから、@samp{c[ad]*r}は、
  770: @samp{cr}、@samp{car}、@samp{cdr}、@samp{caddaar}などに一致することがわかる。
  771: 
  772: @c You can also include character ranges in a character set, by writing the
  773: @c starting and ending characters with a @samp{-} between them.  Thus,
  774: @c @samp{[a-z]} matches any lower-case ASCII letter.  Ranges may be
  775: @c intermixed freely with individual characters, as in @samp{[a-z$%.]},
  776: @c which matches any lower-case ASCII letter or @samp{$}, @samp{%} or
  777: @c period.
  778: 文字集合には、文字範囲の指定を含めることもでき、
  779: 始めの文字と終りの文字のあいだに@samp{-}を書く。
  780: つまり、@samp{[a-z]}はすべてのASCII小文字に一致する。
  781: 範囲指定と個々の文字を自由に織り混ぜてよく、
  782: @samp{[a-z$%.]}のように書ける。
  783: これは、任意のASCII小文字、@samp{$}、@samp{%}、ピリオドに一致する。
  784: 
  785: @c Note that the usual regexp special characters are not special inside a
  786: @c character set.  A completely different set of special characters exists
  787: @c inside character sets: @samp{]}, @samp{-} and @samp{^}.
  788: 文字集合の内側では、正規表現の通常の特別な文字を
  789: 特別扱いしないことに注意。
  790: 文字集合の内側では、まったく別の特別な文字、
  791: @samp{]}、@samp{-}、および、@samp{^}が存在する。
  792: 
  793: @c To include a @samp{]} in a character set, you must make it the first
  794: @c character.  For example, @samp{[]a]} matches @samp{]} or @samp{a}.  To
  795: @c include a @samp{-}, write @samp{-} as the first or last character of the
  796: @c set, or put it after a range.  Thus, @samp{[]-]} matches both @samp{]}
  797: @c and @samp{-}.
  798: 文字集合に@samp{]}を含めるには、
  799: @samp{]}を最初の文字として指定する必要がある。
  800: たとえば、@samp{[]a]}は、@samp{]}や@samp{a}に一致する。
  801: @samp{-}を含めるのであれば、@samp{-}を文字集合の最初の文字か
  802: 最後の文字として指定して、範囲指定のあとに置く。
  803: したがって、@samp{[]-]}は、@samp{]}と@samp{-}の両方に一致する。
  804: 
  805: @c To include @samp{^} in a set, put it anywhere but at the beginning of
  806: @c the set.
  807: 文字集合に@samp{^}を含めるには、@samp{^}を文字集合の2番目以降に置く。
  808: 
  809: @c When you use a range in case-insensitive search, you should write both
  810: @c ends of the range in upper case, or both in lower case, or both should
  811: @c be non-letters.  The behavior of a mixed-case range such as @samp{A-z}
  812: @c is somewhat ill-defined, and it may change in future Emacs versions.
  813: 大文字小文字を区別する探索で文字範囲を指定するときは、
  814: 範囲の両端を、大文字だけ、小文字だけ、あるいは、
  815: 英字以外だけで書くべきである。
  816: @samp{A-z}のような大文字小文字を混ぜた文字範囲の動作は、
  817: 定義が明確ではなく、将来のEmacsでは変更するかもしれない。
  818: 
  819: @item [^ @dots{} ]
  820: @c @samp{[^} begins a @dfn{complemented character set}, which matches any
  821: @c character except the ones specified.  Thus, @samp{[^a-z0-9A-Z]} matches
  822: @c all characters @emph{except} letters and digits.
  823: @samp{[^}は@dfn{文字の補集合}の始まりを意味し、
  824: 指定した文字を除く任意の文字に一致する。
  825: すなわち、@samp{[^a-z0-9A-Z]}は、
  826: 英文字と数字を@emph{除く}すべての文字に一致する。
  827: 
  828: @c @samp{^} is not special in a character set unless it is the first
  829: @c character.  The character following the @samp{^} is treated as if it
  830: @c were first (in other words, @samp{-} and @samp{]} are not special there).
  831: @samp{^}は先頭になければ文字集合では特別な意味を持たない。
  832: @samp{^}に続く文字は先頭にあるものとして扱われる
  833: (いいかえれば、ここでは@samp{-}や@samp{]}は特別な意味を持たない)。
  834: 
  835: @c A complemented character set can match a newline, unless newline is
  836: @c mentioned as one of the characters not to match.  This is in contrast to
  837: @c the handling of regexps in programs such as @code{grep}.
  838: 文字の補集合は、一致しない文字として改行を指定しない限り、改行にも一致する。
  839: この点は、@code{grep}のようなプログラムでの正規表現の扱い方と対照的。
  840: 
  841: @item ^
  842: @c is a special character that matches the empty string, but only at the
  843: @c beginning of a line in the text being matched.  Otherwise it fails to
  844: @c match anything.  Thus, @samp{^foo} matches a @samp{foo} that occurs at
  845: @c the beginning of a line.
  846: 空の文字列に一致する特別な文字で、テキスト行の先頭のみに一致する。
  847: それ以外では、一致に失敗する。
  848: したがって、@samp{^foo}は、行頭にある@samp{foo}に一致する。
  849: 
  850: @item $
  851: @c is similar to @samp{^} but matches only at the end of a line.  Thus,
  852: @c @samp{x+$} matches a string of one @samp{x} or more at the end of a line.
  853: @samp{^}と似ていて、行末のみに一致する。
  854: したがって、@samp{x+$}は、
  855: 行末にある1文字以上の@samp{x}から成る文字列に一致する。
  856: 
  857: @item \
  858: @c has two functions: it quotes the special characters (including
  859: @c @samp{\}), and it introduces additional special constructs.
  860: 2つの機能がある。
  861: (@samp{\}を含む)特別な文字をクォートする(意味を抑える)ことと、
  862: 特別な構成を導入すること。
  863: 
  864: @c Because @samp{\} quotes special characters, @samp{\$} is a regular
  865: @c expression that matches only @samp{$}, and @samp{\[} is a regular
  866: @c expression that matches only @samp{[}, and so on.
  867: @samp{\}は特別な文字をクォートするので、
  868: @samp{\$}は文字@samp{$}だけに一致する正規表現、
  869: @samp{\[}は文字@samp{[}だけに一致する正規表現、
  870: というようになる。
  871: @end table
  872: 
  873: @c Note: for historical compatibility, special characters are treated as
  874: @c ordinary ones if they are in contexts where their special meanings make no
  875: @c sense.  For example, @samp{*foo} treats @samp{*} as ordinary since there is
  876: @c no preceding expression on which the @samp{*} can act.  It is poor practice
  877: @c to depend on this behavior; it is better to quote the special character anyway,
  878: @c regardless of where it appears.@refill
  879: 注意:@code{ }従来との互換性のために、特別な文字が、
  880: それらの特別な意味をなしえない文脈で使われた場合には、
  881: 普通の文字として扱われます。
  882: たとえば、@samp{*foo}では、@samp{*}の対象となる正規表現が直前にないため、
  883: @samp{*}は普通の文字として扱われます。
  884: このようなふるまいに依存することはよい習慣ではありません。
  885: 特別な文字を書く位置に関係なく特別な文字はクォートするべきです。
  886: 
  887: @c For the most part, @samp{\} followed by any character matches only that
  888: @c character.  However, there are several exceptions: two-character
  889: @c sequences starting with @samp{\} that have special meanings.  The second
  890: @c character in the sequence is always an ordinary character when used on
  891: @c its own.  Here is a table of @samp{\} constructs.
  892: 多くの場合、任意の文字を伴う@samp{\}はその文字だけに一致します。
  893: しかし、いくつか例外があって、
  894: @samp{\}で始まる2文字列が特別な意味を持つ場合があります。
  895: 2文字目にくる文字は、
  896: 単独で使った場合には普通の文字として扱われるものです。
  897: 以下に@samp{\}の構成を列挙します。
  898: 
  899: @table @kbd
  900: @item \|
  901: @c specifies an alternative.  Two regular expressions @var{a} and @var{b}
  902: @c with @samp{\|} in between form an expression that matches some text if
  903: @c either @var{a} matches it or @var{b} matches it.  It works by trying to
  904: @c match @var{a}, and if that fails, by trying to match @var{b}.
  905: 選択肢を指定する。
  906: @samp{\|}をあいだに伴った2つの正規表現@var{a}と@var{b}は、
  907: @var{a}か@var{b}のいずれかに一致する文字列に一致する正規表現となる。
  908: 
  909: @c Thus, @samp{foo\|bar} matches either @samp{foo} or @samp{bar}
  910: @c but no other string.@refill
  911: したがって、@samp{foo\|bar}は、@samp{foo}か@samp{bar}に一致するが、
  912: それ以外の文字列には一致しない。
  913: 
  914: @c @samp{\|} applies to the largest possible surrounding expressions.  Only a
  915: @c surrounding @samp{\( @dots{} \)} grouping can limit the grouping power of
  916: @c @samp{\|}.@refill
  917: @samp{\|}は、周囲にある適用しうる正規表現の中でも最大のものに適用される。
  918: @samp{\|}によるグループ化を制限するのは、
  919: これを囲む@samp{\( @dots{} \)}によるグループ化だけ。
  920: 
  921: @c Full backtracking capability exists to handle multiple uses of @samp{\|}.
  922: 何度@samp{\|}を使っても処理できるだけの十分なバックトラック能力がある。
  923: 
  924: @item \( @dots{} \)
  925: @c is a grouping construct that serves three purposes:
  926: 以下の3つの目的を果たすグループ化のための構成。
  927: 
  928: @enumerate
  929: @item
  930: @c To enclose a set of @samp{\|} alternatives for other operations.
  931: @c Thus, @samp{\(foo\|bar\)x} matches either @samp{foox} or @samp{barx}.
  932: 他の操作に使うために一連の選択肢@samp{\|}を括る。
  933: したがって、@samp{\(foo\|bar\)x}は、
  934: @samp{foox}か@samp{barx}のいずれかに一致する。
  935: 
  936: @item
  937: @c To enclose a complicated expression for the postfix operators @samp{*},
  938: @c @samp{+} and @samp{?} to operate on.  Thus, @samp{ba\(na\)*} matches
  939: @c @samp{bananana}, etc., with any (zero or more) number of @samp{na}
  940: @c strings.@refill
  941: 後置演算子、@samp{*}、@samp{+}、@samp{?}を適用できるように、
  942: 複雑な正規表現を括る。
  943: したがって、@samp{ba\(na\)*}は、
  944: @samp{bananana}のように、(0個以上の)任意個の
  945: 文字列@samp{na}に一致する。
  946: 
  947: @item
  948: @c To record a matched substring for future reference.
  949: あとで参照できるように、一致した部分文字列を記録する。
  950: @end enumerate
  951: 
  952: @c This last application is not a consequence of the idea of a
  953: @c parenthetical grouping; it is a separate feature that is assigned as a
  954: @c second meaning to the same @samp{\( @dots{} \)} construct.  In practice
  955: @c there is no conflict between the two meanings.
  956: 最後の使い方は、括弧によるグループ化という考え方から
  957: 派生したものではない。
  958: 同一の@samp{\( @dots{} \)}構成に与えた2つめの別の機能である。
  959: 実用上、これら2つの意味が混同されることはない。
  960: 
  961: @item \@var{d}
  962: @c matches the same text that matched the @var{d}th occurrence of a
  963: @c @samp{\( @dots{} \)} construct.
  964: @var{d}番目に現れた@samp{\( @dots{} \)}に一致したテキストと
  965: 同じテキストに一致する。
  966: 
  967: @c After the end of a @samp{\( @dots{} \)} construct, the matcher remembers
  968: @c the beginning and end of the text matched by that construct.  Then,
  969: @c later on in the regular expression, you can use @samp{\} followed by the
  970: @c digit @var{d} to mean ``match the same text matched the @var{d}th time
  971: @c by the @samp{\( @dots{} \)} construct.''
  972: 一致を処理するときには、@samp{\( @dots{} \)}構成の末尾に達すると、
  973: この構成に一致したテキストの始めと終りを記録する。
  974: そして、正規表現のそれよりうしろでは、
  975: 『@var{d}番目に現れた@samp{\( @dots{} \)}に一致したテキスト』という意味で
  976: @samp{\}に続けて数字@var{d}を使える。
  977: 
  978: @c The strings matching the first nine @samp{\( @dots{} \)} constructs
  979: @c appearing in a regular expression are assigned numbers 1 through 9 in
  980: @c the order that the open-parentheses appear in the regular expression.
  981: @c So you can use @samp{\1} through @samp{\9} to refer to the text matched
  982: @c by the corresponding @samp{\( @dots{} \)} constructs.
  983: 1つの正規表現内に現れる最初の9個の@samp{\( @dots{} \)}に一致する文字列には、
  984: 正規表現中で開き括弧が現れた順に、1から9までの番号を割りふる。
  985: そのため、@samp{\1}から@samp{\9}で、
  986: 対応する@samp{\( @dots{} \)}に一致したテキストを参照できる。
  987: 
  988: @c For example, @samp{\(.*\)\1} matches any newline-free string that is
  989: @c composed of two identical halves.  The @samp{\(.*\)} matches the first
  990: @c half, which may be anything, but the @samp{\1} that follows must match
  991: @c the same exact text.
  992: たとえば、@samp{\(.*\)\1}は、改行を含まない文字列で、かつ、
  993: 前半と後半が同一である文字列に一致する。
  994: @samp{\(.*\)}は前半部分に一致し、それはどのようなものでもかまわない。
  995: 一方、それに続く@samp{\1}は、
  996: 前半部分とまったく同じテキストに一致しなければならない。
  997: 
  998: @c If a particular @samp{\( @dots{} \)} construct matches more than once
  999: @c (which can easily happen if it is followed by @samp{*}), only the last
 1000: @c match is recorded.
 1001: ある@samp{\( @dots{} \)}が、
 1002: (直後に@samp{*}がある場合などに簡単に起こりえる)
 1003: 複数回一致する場合には、最後に一致したものだけを記録する。
 1004: 
 1005: @item \`
 1006: @c matches the empty string, but only at the beginning
 1007: @c of the buffer or string being matched against.
 1008: 空の文字列に一致するが、
 1009: 一致対象であるバッファや文字列の先頭に限る。
 1010: 
 1011: @item \'
 1012: @c matches the empty string, but only at the end of
 1013: @c the buffer or string being matched against.
 1014: 空の文字列に一致するが、
 1015: 一致対象であるバッファや文字列の末尾に限る。
 1016: 
 1017: @item \=
 1018: @c matches the empty string, but only at point.
 1019: 空の文字列に一致するが、ポイント位置に限る。
 1020: 
 1021: @item \b
 1022: @c matches the empty string, but only at the beginning or
 1023: @c end of a word.  Thus, @samp{\bfoo\b} matches any occurrence of
 1024: @c @samp{foo} as a separate word.  @samp{\bballs?\b} matches
 1025: @c @samp{ball} or @samp{balls} as a separate word.@refill
 1026: 同じく空の文字列に一致するが、単語の先頭や末尾に限る。
 1027: したがって、@samp{\bfoo\b}は、単語として独立して現れる@samp{foo}に一致する。
 1028: @samp{\bballs?\b}は、単語として独立して現れる
 1029: @samp{ball}や@samp{balls}に一致する。
 1030: 
 1031: @c @samp{\b} matches at the beginning or end of the buffer
 1032: @c regardless of what text appears next to it.
 1033: @samp{\b}は、
 1034: バッファの先頭や末尾にあるテキストとは無関係に、
 1035: バッファの先頭や末尾にも一致する。
 1036: 
 1037: @item \B
 1038: @c matches the empty string, but @emph{not} at the beginning or
 1039: @c end of a word.
 1040: 空の文字列に一致するが、単語の先頭や末尾@emph{以外}に限る。
 1041: 
 1042: @item \<
 1043: @c matches the empty string, but only at the beginning of a word.
 1044: @c @samp{\<} matches at the beginning of the buffer only if a
 1045: @c word-constituent character follows.
 1046: 空の文字列に一致するが、単語の先頭に限る。
 1047: @samp{\<}は、単語構成文字が続く場合に限って、
 1048: バッファの先頭にも一致する。
 1049: 
 1050: @item \>
 1051: @c matches the empty string, but only at the end of a word.  @samp{\>}
 1052: @c matches at the end of the buffer only if the contents end with a
 1053: @c word-constituent character.
 1054: 空の文字列に一致するが、単語の末尾に限る。
 1055: @samp{\>}は、単語構成文字で終了している場合に限って、
 1056: バッファの末尾にも一致する。
 1057: 
 1058: @item \w
 1059: @c matches any word-constituent character.  The syntax table
 1060: @c determines which characters these are.  @xref{Syntax}.
 1061: 任意の単語構成文字に一致する。
 1062: エディタの構文テーブルによってこの文字が決まる。
 1063: @pxref{Syntax}。
 1064: 
 1065: @item \W
 1066: @c matches any character that is not a word-constituent.
 1067: 単語構成文字以外の文字に一致する。
 1068: 
 1069: @item \s@var{c}
 1070: @c matches any character whose syntax is @var{c}.  Here @var{c} is a
 1071: @c character that represents a syntax code: thus, @samp{w} for word
 1072: @c constituent, @samp{-} for whitespace, @samp{(} for open parenthesis,
 1073: @c etc.  Represent a character of whitespace (which can be a newline) by
 1074: @c either @samp{-} or a space character.
 1075: 構文が@var{c}である文字だけに一致する。
 1076: ここで、@var{c}は構文コードを表す文字。
 1077: たとえば、@samp{w}は単語構成要素を、
 1078: @samp{-}は白文字を、@samp{(}は開き括弧を表すといった具合。
 1079: (改行を含む)白文字は、@samp{-}や空白で表す。
 1080: 
 1081: @item \S@var{c}
 1082: @c matches any character whose syntax is not @var{c}.
 1083: 構文が@var{c}でない任意の文字に一致する。
 1084: @end table
 1085: 
 1086: @c   The constructs that pertain to words and syntax are controlled by the
 1087: @c setting of the syntax table (@pxref{Syntax}).
 1088: 単語や構文に関連する構成要素は、
 1089: 構文テーブル(@pxref{Syntax})の設定で制御されます。
 1090: 
 1091: @c   Here is a complicated regexp, used by Emacs to recognize the end of a
 1092: @c sentence together with any whitespace that follows.  It is given in Lisp
 1093: @c syntax to enable you to distinguish the spaces from the tab characters.  In
 1094: @c Lisp syntax, the string constant begins and ends with a double-quote.
 1095: @c @samp{\"} stands for a double-quote as part of the regexp, @samp{\\} for a
 1096: @c backslash as part of the regexp, @samp{\t} for a tab and @samp{\n} for a
 1097: @c newline.
 1098: 複雑な正規表現を以下に示します。
 1099: これは、任意個の白文字がうしろに続く文末を認識するためにEmacsが使うものです。
 1100: 空白とタブ文字を区別できるように、Lispの構文で示してあります。
 1101: Lisp構文では、文字列定数はダブルクォートで始まり、
 1102: ダブルクォートで終ります。
 1103: @samp{\"}は正規表現の一部としてのダブルクォートを表し、
 1104: @samp{\\}は正規表現の一部としてのバックスラッシュを表します。
 1105: @samp{\t}はタブ文字、@samp{\n}は改行文字を表します。
 1106: 
 1107: @example
 1108: "[.?!][]\"')]*\\($\\|\t\\|  \\)[ \t\n]*"
 1109: @end example
 1110: 
 1111: @noindent
 1112: @c This contains four parts in succession: a character set matching period,
 1113: @c @samp{?}, or @samp{!}; a character set matching close-brackets, quotes,
 1114: @c or parentheses, repeated any number of times; an alternative in
 1115: @c backslash-parentheses that matches end-of-line, a tab, or two spaces;
 1116: @c and a character set matching whitespace characters, repeated any number
 1117: @c of times.
 1118: この正規表現は4つの部分が繋がってできています。
 1119: ピリオド、@samp{?}、@samp{!}のいずれかに一致する文字集合。
 1120: 閉じ中括、2種類の引用符、括弧に一致する文字集合の任意回数の繰り返し。
 1121: バックスラッシュ付きの括弧で括った、
 1122: 行末、タブ、空白2つのいずれかに一致する選択肢。
 1123: 白文字に一致する文字集合の任意回数の繰り返し。
 1124: 
 1125: @c   To enter the same regexp interactively, you would type @key{TAB} to
 1126: @c enter a tab, and @kbd{C-j} to enter a newline.  You would also type
 1127: @c single backslashes as themselves, instead of doubling them for Lisp syntax.
 1128: これと同じ正規表現を対話的に入力するときには、
 1129: タブを入力するには@key{TAB}を打ち、
 1130: 改行を入力するには@kbd{C-j}を打ちます。
 1131: また、Lisp構文上ではバックスラッシュを2つ続けてますが、
 1132: 対話的に入力するには、1つのバックスラッシュだけを打ちます。
 1133: 
 1134: @node Search Case, Replace, Regexps, Search
 1135: @c @section Searching and Case
 1136: @section 探索と大文字小文字の区別
 1137: 
 1138: @vindex case-fold-search
 1139: @c   Incremental searches in Emacs normally ignore the case of the text
 1140: @c they are searching through, if you specify the text in lower case.
 1141: @c Thus, if you specify searching for @samp{foo}, then @samp{Foo} and
 1142: @c @samp{foo} are also considered a match.  Regexps, and in particular
 1143: @c character sets, are included: @samp{[ab]} would match @samp{a} or
 1144: @c @samp{A} or @samp{b} or @samp{B}.@refill
 1145: Emacsのインクリメンタルサーチでは、小文字だけで探索文字列を指定すると、
 1146: 探索対象のテキストの大文字小文字の違いを通常無視します。
 1147: したがって、@samp{foo}を探索するように指定すると、
 1148: @samp{Foo}にも@samp{foo}にも一致します。
 1149: 正規表現、特に文字集合の場合でも同様です。
 1150: @samp{[ab]}は、@samp{a}、@samp{A}、@samp{b}、@samp{B}のいずれにも一致します。
 1151: 
 1152: @c   An upper-case letter anywhere in the incremental search string makes
 1153: @c the search case-sensitive.  Thus, searching for @samp{Foo} does not find
 1154: @c @samp{foo} or @samp{FOO}.  This applies to regular expression search as
 1155: @c well as to string search.  The effect ceases if you delete the
 1156: @c upper-case letter from the search string.
 1157: インクリメンタルサーチする探索文字列のどこかに大文字があると、
 1158: 大文字小文字を区別して探索します。
 1159: したがって、@samp{Foo}の探索では、
 1160: @samp{foo}や@samp{FOO}をみつけだせません。
 1161: このことは、文字列の探索だけでなく正規表現の探索にもあてはまります。
 1162: 探索文字列から大文字を消去すれば、この効果はなくなります。
 1163: 
 1164: @c   If you set the variable @code{case-fold-search} to @code{nil}, then
 1165: @c all letters must match exactly, including case.  This is a per-buffer
 1166: @c variable; altering the variable affects only the current buffer, but
 1167: @c there is a default value which you can change as well.  @xref{Locals}.
 1168: @c This variable applies to nonincremental searches also, including those
 1169: @c performed by the replace commands (@pxref{Replace}) and the minibuffer
 1170: @c history matching commands (@pxref{Minibuffer History}).
 1171: 変数@code{case-fold-search}に@code{nil}を設定すれば、
 1172: 大文字小文字の違いを含めて、すべての文字はそのとおりに一致するようになります。
 1173: これは、バッファごとの変数です。
 1174: 変数を変更してもカレントバッファだけに影響しますが、
 1175: 変更可能なデフォルトの値があります。
 1176: @xref{Locals}。
 1177: この変数は、置換コマンド(@pxref{Replace})や
 1178: ミニバッファの履歴探索コマンド(@pxref{Minibuffer History})が
 1179: 行う探索を含む、一括型探索にも適用されます。
 1180: 
 1181: @node Replace, Other Repeating Search, Search Case, Search
 1182: @c @section Replacement Commands
 1183: @section 置換コマンド
 1184: @c @cindex replacement
 1185: @c @cindex search-and-replace commands
 1186: @c @cindex string substitution
 1187: @c @cindex global substitution
 1188: @cindex 置換
 1189: @cindex 探索置換コマンド
 1190: @cindex 文字列置換
 1191: @cindex 大域的な置換
 1192: 
 1193: @c   Global search-and-replace operations are not needed as often in Emacs
 1194: @c as they are in other editors@footnote{In some editors,
 1195: @c search-and-replace operations are the only convenient way to make a
 1196: @c single change in the text.}, but they are available.  In addition to the
 1197: @c simple @kbd{M-x replace-string} command which is like that found in most
 1198: @c editors, there is a @kbd{M-x query-replace} command which asks you, for
 1199: @c each occurrence of the pattern, whether to replace it.
 1200: 大域的な探索置換操作は、他のエディタ
 1201: @footnote{エディタの中には、テキストに1か所の修正を加える場合でさえ、
 1202: 探索置換操作が唯一の手段であるものもある。}
 1203: で必要なほどEmacsでは必要はありませんが、Emacsでも使えます。
 1204: 多くのエディタにあるような単純なコマンド@kbd{M-x replace-string}の他にも、
 1205: パターンの各出現ごとに置換するかどうか尋ねてくる
 1206: @kbd{M-x query-replace}コマンドがあります。
 1207: 
 1208: @c   The replace commands normally operate on the text from point to the
 1209: @c end of the buffer; however, in Transient Mark mode, when the mark is
 1210: @c active, they operate on the region.  The replace commands all replace
 1211: @c one string (or regexp) with one replacement string.  It is possible to
 1212: @c perform several replacements in parallel using the command
 1213: @c @code{expand-region-abbrevs} (@pxref{Expanding Abbrevs}).
 1214: 置換コマンドは、通常、ポイントからバッファの末尾までのテキストを操作します。
 1215: しかし、暫定マーク(transient-mark)モードでは、
 1216: マークが活性である場合にはリージョンを操作します。
 1217: 置換コマンドはどれも、
 1218: 1つの文字列(や正規表現)を1つの置換文字列に置き換えます。
 1219: コマンド@code{expand-region-abbrevs}(@pxref{Expanding Abbrevs})を使って、
 1220: いくつかの置き換えを並行に行うことができます。
 1221: 
 1222: @menu
 1223: * Unconditional Replace::  Replacing all matches for a string.
 1224: * Regexp Replace::         Replacing all matches for a regexp.
 1225: * Replacement and Case::   How replacements preserve case of letters.
 1226: * Query Replace::          How to use querying.
 1227: @end menu
 1228: 
 1229: @node Unconditional Replace, Regexp Replace, Replace, Replace
 1230: @c @subsection Unconditional Replacement
 1231: @subsection 無条件置換
 1232: @findex replace-string
 1233: @findex replace-regexp
 1234: 
 1235: @table @kbd
 1236: @item M-x replace-string @key{RET} @var{string} @key{RET} @var{newstring} @key{RET}
 1237: @c Replace every occurrence of @var{string} with @var{newstring}.
 1238: @var{string}のすべての出現を@var{newstring}で置換する。
 1239: @item M-x replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET}
 1240: @c Replace every match for @var{regexp} with @var{newstring}.
 1241: 正規表現@var{regexp}に一致するものすべてを@var{newstring}で置換する。
 1242: @end table
 1243: 
 1244: @c   To replace every instance of @samp{foo} after point with @samp{bar},
 1245: @c use the command @kbd{M-x replace-string} with the two arguments
 1246: @c @samp{foo} and @samp{bar}.  Replacement happens only in the text after
 1247: @c point, so if you want to cover the whole buffer you must go to the
 1248: @c beginning first.  All occurrences up to the end of the buffer are
 1249: @c replaced; to limit replacement to part of the buffer, narrow to that
 1250: @c part of the buffer before doing the replacement (@pxref{Narrowing}).
 1251: @c In Transient Mark mode, when the region is active, replacement is
 1252: @c limited to the region (@pxref{Transient Mark}).
 1253: ポイント以降にある@samp{foo}のすべての出現を
 1254: @samp{bar}で置き換えるには、2つの引数@samp{foo}と@samp{bar}を指定した
 1255: コマンド@kbd{M-x replace-string}を使います。
 1256: 置換はポイント以降でのみ実施されますから、
 1257: バッファ全体に対して置換を行いたいときには、
 1258: まずバッファの先頭に移動しておく必要があります。
 1259: バッファの末尾までに現れるすべての出現を置換します。
 1260: バッファの一部に置換を限定したいときには、
 1261: 置換を実行するまえに、バッファの当該部分にナロイングしておきます
 1262: (@pxref{Narrowing})。
 1263: 暫定マーク(transient-mark)モードにおいては、
 1264: リージョンが活性のときには、置換はリージョン内に限定されます。
 1265: 
 1266: @c   When @code{replace-string} exits, it leaves point at the last
 1267: @c occurrence replaced.  It sets the mark to the prior position of point
 1268: @c (where the @code{replace-string} command was issued); use @kbd{C-u
 1269: @c C-@key{SPC}} to move back there.
 1270: @code{replace-string}を終了すると、
 1271: ポイントは最後に置換した出現箇所に置かれます。
 1272: マークは(@code{replace-string}コマンドを起動したとき)
 1273: 以前のポイント位置に設定されます。
 1274: その位置に戻るには@kbd{C-u C-@key{SPC}}を使います。
 1275: 
 1276: @c   A numeric argument restricts replacement to matches that are surrounded
 1277: @c by word boundaries.  The argument's value doesn't matter.
 1278: 数引数を指定すると、
 1279: 単語区切りで囲まれた出現だけを置換対象とします。
 1280: 引数の値は関係ありません。
 1281: 
 1282: @node Regexp Replace, Replacement and Case, Unconditional Replace, Replace
 1283: @c @subsection Regexp Replacement
 1284: @subsection 正規表現による置換
 1285: 
 1286: @c   The @kbd{M-x replace-string} command replaces exact matches for a
 1287: @c single string.  The similar command @kbd{M-x replace-regexp} replaces
 1288: @c any match for a specified pattern.
 1289: @kbd{M-x replace-string}コマンドは、
 1290: 1つの文字列に正確に一致するものだけを置き換えます。
 1291: これに類似したコマンド@kbd{M-x replace-regexp}は、
 1292: 指定したパターンに一致する任意のものを置き換えます。
 1293: 
 1294: @c   In @code{replace-regexp}, the @var{newstring} need not be constant: it
 1295: @c can refer to all or part of what is matched by the @var{regexp}.
 1296: @c @samp{\&} in @var{newstring} stands for the entire match being replaced.
 1297: @c @samp{\@var{d}} in @var{newstring}, where @var{d} is a digit, stands for
 1298: @c whatever matched the @var{d}th parenthesized grouping in @var{regexp}.
 1299: @c To include a @samp{\} in the text to replace with, you must enter
 1300: @c @samp{\\}.  For example,
 1301: @code{replace-regexp}では、
 1302: @var{newstring}が定数である必要はありません。
 1303: @var{regexp}に一致したものの全体あるいはその一部を参照できます。
 1304: @var{newstring}の中の@samp{\&}は、
 1305: 置換対象の文字列全体(つまり、@var{regexp}に一致したものの全体)を
 1306: 表します。
 1307: @var{newstring}の中の@samp{\@var{d}}(@var{d}は数字)は、
 1308: @var{regexp}の中の@var{d}番目の括弧のグループ化部分に
 1309: 一致した部分を表します。
 1310: 置き換えるテキスト内に@samp{\}を含めるには、
 1311: @samp{\\}と入力する必要があります。
 1312: 
 1313: @example
 1314: M-x replace-regexp @key{RET} c[ad]+r @key{RET} \&-safe @key{RET}
 1315: @end example
 1316: 
 1317: @noindent
 1318: @c replaces (for example) @samp{cadr} with @samp{cadr-safe} and @samp{cddr}
 1319: @c with @samp{cddr-safe}.
 1320: たとえばこの例は、@samp{cadr}を@samp{cadr-safe}で、
 1321: @samp{cddr}を@samp{cddr-safe}で置換します。
 1322: 
 1323: @example
 1324: M-x replace-regexp @key{RET} \(c[ad]+r\)-safe @key{RET} \1 @key{RET}
 1325: @end example
 1326: 
 1327: @noindent
 1328: @c performs the inverse transformation.
 1329: この例は、逆の置換を行います。
 1330: 
 1331: @node Replacement and Case, Query Replace, Regexp Replace, Replace
 1332: @c @subsection Replace Commands and Case
 1333: @subsection 置換コマンドと大文字小文字の区別
 1334: 
 1335: @c   If the first argument of a replace command is all lower case, the
 1336: @c commands ignores case while searching for occurrences to
 1337: @c replace---provided @code{case-fold-search} is non-@code{nil}.  If
 1338: @c @code{case-fold-search} is set to @code{nil}, case is always significant
 1339: @c in all searches.
 1340: 置換コマンドの第1引数がすべて小文字である場合、
 1341: @code{case-fold-search}が@code{nil}以外であるときには、
 1342: 大文字小文字を区別せずに置換対象を探索します。
 1343: @code{case-fold-search}が@code{nil}であるときには、
 1344: すべての探索において大文字小文字を区別します。
 1345: 
 1346: @vindex case-replace
 1347: @c   In addition, when the @var{newstring} argument is all or partly lower
 1348: @c case, replacement commands try to preserve the case pattern of each
 1349: @c occurrence.  Thus, the command
 1350: さらに、引数@var{newstring}が、すべて小文字、あるいは、
 1351: 一部が小文字のときには、置換コマンドは、
 1352: 各置換対象の大文字小文字のパターンを保存しようとします。
 1353: つまり、コマンド
 1354: 
 1355: @example
 1356: M-x replace-string @key{RET} foo @key{RET} bar @key{RET}
 1357: @end example
 1358: 
 1359: @noindent
 1360: @c replaces a lower case @samp{foo} with a lower case @samp{bar}, an
 1361: @c all-caps @samp{FOO} with @samp{BAR}, and a capitalized @samp{Foo} with
 1362: @c @samp{Bar}.  (These three alternatives---lower case, all caps, and
 1363: @c capitalized, are the only ones that @code{replace-string} can
 1364: @c distinguish.)
 1365: は、小文字の@samp{foo}を小文字の@samp{bar}に、
 1366: すべて大文字の@samp{FOO}を@samp{BAR}に、
 1367: 大文字で始まる@samp{Foo}を@samp{Bar}に置換します。
 1368: (@code{replace-string}が区別できるのは、これら3つの選択肢、
 1369: つまり、小文字のみ、すべて大文字、大文字で始まるだけ。)
 1370: 
 1371: @c   If upper-case letters are used in the replacement string, they remain
 1372: @c upper case every time that text is inserted.  If upper-case letters are
 1373: @c used in the first argument, the second argument is always substituted
 1374: @c exactly as given, with no case conversion.  Likewise, if either
 1375: @c @code{case-replace} or @code{case-fold-search} is set to @code{nil},
 1376: @c replacement is done without case conversion.
 1377: 置換文字列に大文字を使ったときには、
 1378: これを挿入するときは大文字は大文字のままです。
 1379: 第1引数に大文字を使ったときには、
 1380: 第2引数では大文字小文字を変換せずにつねに指定どおりに置き換えます。
 1381: 同様に、@code{case-replace}や@code{case-fold-search}に
 1382: @code{nil}を設定すると、
 1383: 大文字小文字を変換せずに置換します。
 1384: 
 1385: @node Query Replace,, Replacement and Case, Replace
 1386: @c @subsection Query Replace
 1387: @subsection 問い合わせ型置換
 1388: @c @cindex query replace
 1389: @cindex 問い合わせ型置換
 1390: 
 1391: @table @kbd
 1392: @item M-% @var{string} @key{RET} @var{newstring} @key{RET}
 1393: @itemx M-x query-replace @key{RET} @var{string} @key{RET} @var{newstring} @key{RET}
 1394: @c Replace some occurrences of @var{string} with @var{newstring}.
 1395: @var{string}のいくつかの出現を@var{newstring}で置換する。
 1396: @item C-M-% @var{regexp} @key{RET} @var{newstring} @key{RET}
 1397: @itemx M-x query-replace-regexp @key{RET} @var{regexp} @key{RET} @var{newstring} @key{RET}
 1398: @c Replace some matches for @var{regexp} with @var{newstring}.
 1399: 正規表現@var{regexp}に一致するもののいくつかを@var{newstring}で置換する。
 1400: @end table
 1401: 
 1402: @kindex M-%
 1403: @findex query-replace
 1404: @c   If you want to change only some of the occurrences of @samp{foo} to
 1405: @c @samp{bar}, not all of them, then you cannot use an ordinary
 1406: @c @code{replace-string}.  Instead, use @kbd{M-%} (@code{query-replace}).
 1407: @c This command finds occurrences of @samp{foo} one by one, displays each
 1408: @c occurrence and asks you whether to replace it.  A numeric argument to
 1409: @c @code{query-replace} tells it to consider only occurrences that are
 1410: @c bounded by word-delimiter characters.  This preserves case, just like
 1411: @c @code{replace-string}, provided @code{case-replace} is non-@code{nil},
 1412: @c as it normally is.
 1413: @samp{foo}のすべての出現ではなく、
 1414: そのうちのいくつかだけを@samp{bar}に変更したいときには、
 1415: 通常の@code{replace-string}を使うことはできません。
 1416: かわりに、@kbd{M-%}(@code{query-replace})を使います。
 1417: このコマンドは@samp{foo}の出現をみつけるたびに、
 1418: その出現を表示し、置換するかどうか聞いてきます。
 1419: @code{query-replace}に数引数を指定すると、
 1420: 単語区切り文字で区切られた出現だけを対象とします。
 1421: 通常どおり@code{case-replace}が@code{nil}以外であれば、
 1422: @code{replace-string}と同じく、
 1423: このコマンドも大文字小文字の違いを保存します。
 1424: 
 1425: @kindex C-M-%
 1426: @findex query-replace-regexp
 1427: @c   Aside from querying, @code{query-replace} works just like
 1428: @c @code{replace-string}, and @code{query-replace-regexp} works just like
 1429: @c @code{replace-regexp}.  This command is run by @kbd{C-M-%}.
 1430: 問い合わせることを除けば、
 1431: @code{query-replace}は@code{replace-string}と同様に動作し、
 1432: @code{query-replace-regexp}は@code{replace-regexp}と同様に動作します。
 1433: このコマンドは、@kbd{C-M-%}で実行できます。
 1434: 
 1435: @c   The things you can type when you are shown an occurrence of @var{string}
 1436: @c or a match for @var{regexp} are:
 1437: @var{string}の出現や@var{regexp}に一致したものが表示されたときに
 1438: 打てる文字はつぎのとおりです。
 1439: 
 1440: @ignore @c Not worth it.
 1441: @kindex SPC @r{(query-replace)}
 1442: @kindex DEL @r{(query-replace)}
 1443: @kindex , @r{(query-replace)}
 1444: @kindex RET @r{(query-replace)}
 1445: @kindex . @r{(query-replace)}
 1446: @kindex ! @r{(query-replace)}
 1447: @kindex ^ @r{(query-replace)}
 1448: @kindex C-r @r{(query-replace)}
 1449: @kindex C-w @r{(query-replace)}
 1450: @kindex C-l @r{(query-replace)}
 1451: @end ignore
 1452: 
 1453: @c WideCommands
 1454: @table @kbd
 1455: @item @key{SPC}
 1456: @c to replace the occurrence with @var{newstring}.
 1457: 出現を@var{newstring}で置換する。
 1458: 
 1459: @item @key{DEL}
 1460: @c to skip to the next occurrence without replacing this one.
 1461: この出現を置換せずにつぎの出現箇所に進む。
 1462: 
 1463: @c @item , @r{(Comma)}
 1464: @item , @r{(カンマ)}
 1465: @c to replace this occurrence and display the result.  You are then asked
 1466: @c for another input character to say what to do next.  Since the
 1467: @c replacement has already been made, @key{DEL} and @key{SPC} are
 1468: @c equivalent in this situation; both move to the next occurrence.
 1469: この出現を置換し、結果を表示する。
 1470: そして、つぎに何をするか指示する文字を聞いてくる。
 1471: 置換自体はすでに完了しているので、
 1472: この状況では@key{DEL}と@key{SPC}は等価であり、
 1473: つぎの出現箇所へ移動するという意味。
 1474: 
 1475: @c You can type @kbd{C-r} at this point (see below) to alter the replaced
 1476: @c text.  You can also type @kbd{C-x u} to undo the replacement; this exits
 1477: @c the @code{query-replace}, so if you want to do further replacement you
 1478: @c must use @kbd{C-x @key{ESC} @key{ESC} @key{RET}} to restart
 1479: @c (@pxref{Repetition}).
 1480: この時点では、@kbd{C-r}(下記参照)を打って、置換したテキストを変更できる。
 1481: また、@kbd{C-x u}と打って、置換をアンドゥする(もとに戻す)こともできるが、
 1482: そうすると、@code{query-replace}を終了してしまう。
 1483: さらに先の置換を行いたいときには、
 1484: @kbd{C-x @key{ESC} @key{ESC} @key{RET}}を使って再開する必要がある
 1485: (@pxref{Repetition})。
 1486: 
 1487: @item @key{RET}
 1488: @c to exit without doing any more replacements.
 1489: これ以上何も置換しないで終了する。
 1490: 
 1491: @c @item .@: @r{(Period)}
 1492: @item .@: @r{(ピリオド)}
 1493: @c to replace this occurrence and then exit without searching for more
 1494: @c occurrences.
 1495: この出現を置換してから、これ以上探索せずに終了する。
 1496: 
 1497: @item !
 1498: @c to replace all remaining occurrences without asking again.
 1499: これ以降、問い合わせずに残りの出現すべてを置換する。
 1500: 
 1501: @item ^
 1502: @c to go back to the position of the previous occurrence (or what used to
 1503: @c be an occurrence), in case you changed it by mistake.  This works by
 1504: @c popping the mark ring.  Only one @kbd{^} in a row is meaningful, because
 1505: @c only one previous replacement position is kept during @code{query-replace}.
 1506: 誤って変更してしまった場合などに、
 1507: 1つまえの出現箇所(あるいは置換してしまった出現箇所)に戻る。
 1508: これは、マークリングから位置を取り出して動作する。
 1509: @code{query-replace}は直前の1つの置換位置だけを記録するため、
 1510: @kbd{^}を続けて入力しても意味はない。
 1511: 
 1512: @item C-r
 1513: @c to enter a recursive editing level, in case the occurrence needs to be
 1514: @c edited rather than just replaced with @var{newstring}.  When you are
 1515: @c done, exit the recursive editing level with @kbd{C-M-c} to proceed to
 1516: @c the next occurrence.  @xref{Recursive Edit}.
 1517: 単に@var{newstring}で置換するだけでなく、
 1518: この出現を編集する必要がある場合などに、再帰編集レベルに入る。
 1519: 編集し終えて@kbd{C-M-c}で再帰編集を抜けると、つぎの出現箇所に移動する。
 1520: @pxref{Recursive Edit}。
 1521: 
 1522: @item C-w
 1523: @c to delete the occurrence, and then enter a recursive editing level as in
 1524: @c @kbd{C-r}.  Use the recursive edit to insert text to replace the deleted
 1525: @c occurrence of @var{string}.  When done, exit the recursive editing level
 1526: @c with @kbd{C-M-c} to proceed to the next occurrence.
 1527: 出現を削除してから、@kbd{C-r}と同様に再帰編集レベルに入る。
 1528: 再帰編集を使って、削除した@var{string}の出現を置き換えるテキストを挿入する。
 1529: 編集し終えて@kbd{C-M-c}で再帰編集を抜けると、つぎの出現箇所に移動する。
 1530: 
 1531: @item C-l
 1532: @c to redisplay the screen.  Then you must type another character to
 1533: @c specify what to do with this occurrence.
 1534: 画面を再表示する。
 1535: そうしたら、この出現に対して何を行うかを指示する別の文字を打つ必要がある。
 1536: 
 1537: @item C-h
 1538: @c to display a message summarizing these options.  Then you must type
 1539: @c another character to specify what to do with this occurrence.
 1540: これらのオプションの要約メッセージを表示する。
 1541: そうしたら、この出現に対して何を行うかを指示する別の文字を打つ必要がある。
 1542: @end table
 1543: 
 1544: @c   Some other characters are aliases for the ones listed above: @kbd{y},
 1545: @c @kbd{n} and @kbd{q} are equivalent to @key{SPC}, @key{DEL} and
 1546: @c @key{RET}.
 1547: 上記のコマンドの別名である文字が他にもいくつかあります。
 1548: @kbd{y}、@kbd{n}、@kbd{q}は、それぞれ、
 1549: @key{SPC}、@key{DEL}、@key{RET}に等価です。
 1550: 
 1551: @c   Aside from this, any other character exits the @code{query-replace},
 1552: @c and is then reread as part of a key sequence.  Thus, if you type
 1553: @c @kbd{C-k}, it exits the @code{query-replace} and then kills to end of
 1554: @c line.
 1555: これ以外の文字は@code{query-replace}を終了し、
 1556: その文字はキー列の一部になります。
 1557: したがって、@kbd{C-k}と打つと、
 1558: @code{query-replace}を終了してから、行末までをキルします。
 1559: 
 1560: @c   To restart a @code{query-replace} once it is exited, use @kbd{C-x
 1561: @c @key{ESC} @key{ESC}}, which repeats the @code{query-replace} because it
 1562: @c used the minibuffer to read its arguments.  @xref{Repetition, C-x ESC
 1563: @c ESC}.
 1564: 一度抜けた@code{query-replace}を再開するには、
 1565: @kbd{C-x @key{ESC} @key{ESC}}を使います。
 1566: このコマンドは@code{query-replace}を繰り返します。
 1567: というのは、@code{query-replace}はミニバッファで引数を読み取るからです。
 1568: @xref{Repetition, C-x ESC ESC}。
 1569: 
 1570: @c   See also @ref{Transforming File Names}, for Dired commands to rename,
 1571: @c copy, or link files by replacing regexp matches in file names.
 1572: ファイル名に対して正規表現に一致する部分を置換することで、
 1573: ファイルの改名、コピー、リンクを行うdiredコマンドについては、
 1574: @ref{Transforming File Names}も参照してください。
 1575: 
 1576: @node Other Repeating Search,, Replace, Search
 1577: @c @section Other Search-and-Loop Commands
 1578: @section 他の探索繰り返しコマンド
 1579: 
 1580: @c   Here are some other commands that find matches for a regular
 1581: @c expression.  They all operate from point to the end of the buffer, and
 1582: @c all ignore case in matching, if the pattern contains no upper-case
 1583: @c letters and @code{case-fold-search} is non-@code{nil}.
 1584: 正規表現に一致するものをみつけるコマンドは、他にもいくつかあります。
 1585: それらは、ポイント位置からバッファの末尾までを操作対象とします。
 1586: さらに、パターンに大文字が含まれていないときや、
 1587: @code{case-fold-search}が@code{nil}以外であるときには、
 1588: 大文字小文字の違いを無視して一致を探します。
 1589: 
 1590: @findex list-matching-lines
 1591: @findex occur
 1592: @findex count-matches
 1593: @findex delete-non-matching-lines
 1594: @findex delete-matching-lines
 1595: @findex flush-lines
 1596: @findex keep-lines
 1597: 
 1598: @table @kbd
 1599: @item M-x occur @key{RET} @var{regexp} @key{RET}
 1600: @c Display a list showing each line in the buffer that contains a match for
 1601: @c @var{regexp}.  A numeric argument specifies the number of context lines
 1602: @c to print before and after each matching line; the default is none.
 1603: @c To limit the search to part of the buffer, narrow to that part
 1604: @c (@pxref{Narrowing}).
 1605: @var{regexp}に一致するものを含むバッファ内の各行の一覧を表示する。
 1606: 数引数で、一致した各行の前後何行を表示するか指定する。
 1607: デフォルトは0行。
 1608: バッファの一部に探索を制限するには、
 1609: その部分にナロイングする(@pxref{Narrowing})。
 1610: 
 1611: @c @kindex RET @r{(Occur mode)}
 1612: @kindex RET @r{(出現モード)}
 1613: @c The buffer @samp{*Occur*} containing the output serves as a menu for
 1614: @c finding the occurrences in their original context.  Click @kbd{Mouse-2}
 1615: @c on an occurrence listed in @samp{*Occur*}, or position point there and
 1616: @c type @key{RET}; this switches to the buffer that was searched and
 1617: @c moves point to the original of the chosen occurrence.
 1618: 出力を表示したバッファ@samp{*Occur*}は、
 1619: もとの文脈での出現位置を探すためのメニューとして機能する。
 1620: @samp{*Occur*}に表示された出現を@kbd{Mouse-2}でクリックするか、あるいは、
 1621: ポイントをそこに置いて@key{RET}を打つ。
 1622: この操作により、探索を行ったバッファに切り替え、
 1623: 選択した出現のもとの位置にポイントを移動する。
 1624: 
 1625: @item M-x list-matching-lines
 1626: @c Synonym for @kbd{M-x occur}.
 1627: @kbd{M-x occur}と同じ。
 1628: 
 1629: @item M-x count-matches @key{RET} @var{regexp} @key{RET}
 1630: @c Print the number of matches for @var{regexp} after point.
 1631: ポイント以降で@var{regexp}に一致するものの個数を表示する。
 1632: 
 1633: @item M-x flush-lines @key{RET} @var{regexp} @key{RET}
 1634: @c Delete each line that follows point and contains a match for
 1635: @c @var{regexp}.
 1636: ポイント以降にあって@var{regexp}に一致するものを含む各行を削除する。
 1637: 
 1638: @item M-x keep-lines @key{RET} @var{regexp} @key{RET}
 1639: @c Delete each line that follows point and @emph{does not} contain a match
 1640: @c for @var{regexp}.
 1641: ポイント以降にあって@var{regexp}に一致するものを
 1642: 含ま@emph{ない}各行を削除する。
 1643: @end table
 1644: 
 1645: @c   In addition, you can use @code{grep} from Emacs to search a collection
 1646: @c of files for matches for a regular expression, then visit the matches
 1647: @c either sequentially or in arbitrary order.  @xref{Grep Searching}.
 1648: さらに、Emacsから@code{grep}を使って、
 1649: 一連のファイルに対して正規表現に一致するものを探して、
 1650: 一致するものを含むファイルを順番に、あるいは、
 1651: 任意の順に訪問できます。
 1652: @xref{Grep Searching}。

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