runtime/doc/eval.jax

   1 *eval.txt*      For Vim バージョン 7.2.  Last change: 2009 Nov 17
   2
   3
   4                 VIMリファレンスマニュアル    by Bram Moolenaar
   5
   6
   7 Vimスクリプト                                *expression* *expr* *E15* *eval*
   8
   9 Vimスクリプトの利用についてはユーザマニュアルの41章|usr_41.txt|でも解説されて
  10 いる。
  11
  12 注意:Vimスクリプトはコンパイル時に無効化できる。もしそうなっているとこのドキュ
  13 メントに書かれている事は有効ではない。|+eval|と|no-eval-feature|を参照。
  14
  15 1.  変数          |variables|
  16     1.1 変数の型
  17     1.2 関数への参照                  |Funcref|
  18     1.3 リスト                             |Lists|
  19     1.4 辞書                              |Dictionaries|
  20     1.5 変数について補足                |more-variables|
  21 2.  式の文法                |expression-syntax|
  22 3.  内部変数                |internal-variables|
  23 4.  組み込み関数      |functions|
  24 5.  関数定義                |user-functions|
  25 6.  波括弧{}変数     |curly-braces-names|
  26 7.  コマンド                |expression-commands|
  27 8.  例外処理                |exception-handling|
  28 9.  例                   |eval-examples|
  29 10. +eval機能が無効  |no-eval-feature|
  30 11. サンドボックス     |eval-sandbox|
  31 12. テキストロック     |textlock|
  32
  33 {Vi にはこれらのコマンドは存在しない}
  34
  35 ==============================================================================
  36 1. 変数                                                   *variables*
  37
  38 1.1 変数の型 ~
  39                                                         *E712*
  40 変数には6種類の型がある:
  41
  42 数値              32ビット符合有整数  |expr-number| *Number*
  43                 例: -123 0x10 0177
  44
  45 浮動小数点数  浮動小数点数  |floating-point-format| *Float*
  46                 {|+float| 機能つきでコンパイルされたときのみ}
  47                 例: 123.456  1.15e-6  -1.1e3
  48
  49 文字列             終端がNUL文字である8ビットの符号無し文字(バイト)
  50                 |expr-string| 例: "ab\txx\"--"  'x-z''a,c'
  51
  52 Funcref         関数への参照 |Funcref|.
  53                 例: function("strlen")
  54
  55 リスト             要素の順序つきの列 |List|.
  56                 例: [1, 2, ['a', 'b']]
  57
  58 辞書              順序を持たない連想配列: 各要素はキーと値を持つ。|Dictionary|
  59                 例: {'blue': "#0000ff", 'red': "#ff0000"}
  60
  61 数値と文字列は文脈に応じて相互に変換される。
  62
  63 数値から文字列への変換は数字のASCII表現によって行なわれる。例: >
  64         数値 123  -->     文字列 "123"
  65         数値 0            -->     文字列 "0"
  66         数値 -1           -->     文字列 "-1"
  67
  68 文字列から数値への変換は最初の数字を用いて数値に変換する。16進表記"0xf9"や8進
  69 表記"017"も認識される。文字列が数字で始まらない場合結果は0となる。例: >
  70         文字列 "456"       -->     数値 456
  71         文字列 "6bar"      -->     数値 6
  72         文字列 "foo"       -->     数値 0
  73         文字列 "0xf1"      -->     数値 241
  74         文字列 "0100"      -->     数値 64
  75         文字列 "-8"        -->     数値 -8
  76         文字列 "+8"        -->     数値 0
  77
  78 文字列を強制的に数値に変換するには0を足す: >
  79         :echo "0100" + 0
  80 <       64 ~
  81
  82 先頭の0によって8進数とみなされるのを防いだり、異なる基数を使うには|str2nr()|を
  83 使う。
  84
  85 ブール(真理値)演算には数値が使われる。0は偽を意味し、非0は真を表す。
  86
  87 Note 次のコマンドをみると >
  88         :if "foo"
  89 "foo"は0に変換され、それは偽を意味する。文字列が空ではないか調べるためには
  90 strlen()を使用して次のようにする。 >
  91         :if strlen("foo")
  92 <                               *E745* *E728* *E703* *E729* *E730* *E731*
  93 リスト、辞書、Funcrefは自動的に変換されない。
  94
  95                                                         *E805* *E806* *E808*
  96 数値と浮動小数点数をまぜると浮動小数点数になる。それ以外には浮動小数点数への自
  97 動的な変換は存在しない。文字列から浮動小数点数へは str2float () を使い、浮動小
  98 数点数から文字列へは printf()を、浮動小数点数から数値へは float2nr() を使う。
  99
 100                                                 *E706* *sticky-type-checking*
 101 変数の型を変えようとするとエラーになる。このエラーを避けるには、まず|:unlet|す
 102 る必要がある。しかし文字列と数値は同値であると見なされる。同じく、浮動小数点数
 103 と数値も同値であるとみなされる。例: >
 104         :let l = "string"
 105         :let l = 44             " 型が文字列から数値に変わる
 106         :let l = [1, 2, 3]      " エラー! l はまだ数値である
 107         :let l = 4.4            " 型が数値から浮動小数点数に変わる
 108         :let l = "string"       " エラー!
 109
 110
 111 1.2 関数への参照 ~
 112                                         *Funcref* *E695* *E718*
 113 関数|function()|は関数への参照を返す。関数への参照は、式の中で関数名が要求され
 114 る場所で使うと参照先の関数を呼び出す。例: >
 115
 116         :let Fn = function("MyFunc")
 117         :echo Fn()
 118 <                                                       *E704* *E705* *E707*
 119 関数参照の変数名は、大文字、"s:"、"w:"、"t:"、"b:"のいずれかで始めなければなら
 120 ない。関数参照と参照先の関数の名前を同じにすることはできない。
 121
 122 関数を定義して、それへの参照を直接辞書に入れるための特別な形式がある。例: >
 123         :function dict.init() dict
 124         :   let self.val = 0
 125         :endfunction
 126
 127 この辞書のキーは小文字で始めなければならない。実際の関数名はここでは使われない。
 128 |numbered-function|も参照。
 129
 130 |:call|コマンドでも関数参照を使うことができる: >
 131         :call Fn()
 132         :call dict.init()
 133
 134 参照先の関数名は|string()|で得られる。 >
 135         :let func = string(Fn)
 136
 137 関数参照を呼び出すには|call()|を使い、引数にはリスト型の変数を使う: >
 138         :let r = call(Fn, mylist)
 139
 140
 141 1.3 リスト ~
 142                                                         *List* *Lists* *E686*
 143 リストとは順序を保つ要素の列である。要素はどんな型でもよい。要素へはインデック
 144 ス番号を使ってアクセスする。列の任意の位置に要素を追加したり削除することができ
 145 る。
 146
 147
 148 リストの作成 ~
 149                                                         *E696* *E697*
 150 リストを作るには、[]の中にコンマで区切って要素を書く。
 151 例: >
 152         :let mylist = [1, two, 3, "four"]
 153         :let emptylist = []
 154
 155 要素はどんな式でもよい。要素としてリストを指定すると、リストのリストができる:
 156 >
 157         :let nestlist = [[11, 12], [21, 22], [31, 32]]
 158
 159 最後の要素の後に余分なコンマがあると無視される。
 160
 161
 162 リストのインデックス ~
 163                                                         *list-index* *E684*
 164 リストの要素にアクセスするには、リスト名の後に[]を書き、その中にインデックスを
 165 書く。インデックスは0基点(つまり最初の要素のインデックスは0)である。 >
 166         :let item = mylist[0]           " 最初の要素(1)を取得
 167         :let item = mylist[2]           " 3番目の要素(3)を取得
 168
 169 取得した要素がリストならば、さらに続けてインデックスを書くことができる: >
 170         :let item = nestlist[0][1]      " 最初のリストの2番目の要素(12)を取得
 171 <
 172 負のインデックスを指定すると、リストの末尾から数えられる。インデックス-1は最後
 173 の要素を示し、-2は最後から2番目を指す >
 174         :let last = mylist[-1]          " 最後の要素("four")を取得
 175
 176 無効なインデックスによるエラーを回避するには関数|get()|を使う。するとインデッ
 177 クスが無効な場合は、0かまたは自分で指定した既定値が返る: >
 178         :echo get(mylist, idx)
 179         :echo get(mylist, idx, "NONE")
 180
 181
 182 リストの連結 ~
 183
 184 2つのリストを連結するには演算子"+"を使う: >
 185         :let longlist = mylist + [5, 6]
 186         :let mylist += [7, 8]
 187
 188 1個の要素を先頭または末尾に付け加えるには、[]で囲んでリストにして連結する。リ
 189 ストの特定の要素を変更するには後述の|list-modification|を参照。
 190
 191
 192 部分リスト ~
 193
 194 リストの一部分を取り出すには、[]の中に始点と終点のインデックスを書き、コロンで
 195 区切る: >
 196         :let shortlist = mylist[2:-1]   " リスト[3, "four"]を得る
 197
 198 始点のインデックスを省略すると0となる。終点のインデックスを省略すると-1となる >
 199         :let endlist = mylist[2:]       " 2番目から最後まで: [3, "four"]
 200         :let shortlist = mylist[2:2]    " 1個の要素からなるリスト: [3]
 201         :let otherlist = mylist[:]      " リストのコピーを作る
 202
 203 終点のインデックスが始点のインデックスよりも前になってしまった場合は空リストと
 204 なる。エラーメッセージは表示されない。
 205
 206 終点のインデックスがリストの長さより大きい場合は、長さ-1を指定したときと同じに
 207 なる: >
 208         :let mylist = [0, 1, 2, 3]
 209         :echo mylist[2:8]               " 結果: [2, 3]
 210
 211 NOTE: mylist[s:e]と書くと変数"s:e"をインデックスとして使ったと解釈される。":"
 212 の前に1文字の変数を使うときは十分注意すること。必要ならこのようにスペースを入
 213 れるとよい: mylist[s : e].
 214
 215
 216 リストの同一性 ~
 217                                                         *list-identity*
 218 変数"aa"がリストであり、それを別の変数"bb"に代入したとすると、両方とも同じ変数
 219 を参照するようになる。よってリスト"aa"を変更すると"bb"も変更される: >
 220         :let aa = [1, 2, 3]
 221         :let bb = aa
 222         :call add(aa, 4)
 223         :echo bb
 224 <       [1, 2, 3, 4]
 225
 226 リストのコピーを作るには関数|copy()|を使う。前述の通り[:]を使ってもできる。こ
 227 れは浅いコピーである。つまりリストの要素であるリストに変更を加えると、コピーさ
 228 れたリスト内の同じ要素も変更される: >
 229         :let aa = [[1, 'a'], 2, 3]
 230         :let bb = copy(aa)
 231         :call add(aa, 4)
 232         :let aa[0][1] = 'aaa'
 233         :echo aa
 234 <       [[1, aaa], 2, 3, 4] >
 235         :echo bb
 236 <       [[1, aaa], 2, 3]
 237
 238 完全に独立したコピーを作るには|deepcopy()|を使う。これは再帰的にリストの要素の
 239 コピーを作る。ただし深さは100レベルまでである。
 240
 241 2つの変数が同じリストを指しているかは演算子"is"で判定できる。"isnot"はその逆で
 242 ある。一方、"=="は2つのリストが同じ値を持っているかを判定する。 >
 243         :let alist = [1, 2, 3]
 244         :let blist = [1, 2, 3]
 245         :echo alist is blist
 246 <       0 >
 247         :echo alist == blist
 248 <       1
 249
 250 Note リストの比較について注意: 2つのリストは、同じ長さを持ち、全要素が"=="の意
 251 味で等しいとき、等しいとみなされる。ただ、1つ例外がある: 数値と文字列を比較す
 252 るとそれらは異なるとみなされる。変数に対して"=="で比較したときに行われるような
 253 自動的な型変換は行われない。例: >
 254         echo 4 == "4"
 255 <       1 >
 256         echo [4] == ["4"]
 257 <       0
 258
 259 つまり、リストの比較は数値や文字列の比較よりも厳格である。単純な値もリストに入
 260 れることによりこの方法で比較することができる: >
 261
 262         :let a = 5
 263         :let b = "5"
 264         :echo a == b
 265 <       1 >
 266         :echo [a] == [b]
 267 <       0
 268
 269
 270 リストのアンパック ~
 271
 272 リストの要素を個々の変数としてアンパックするには、[]の中に変数を書く: >
 273         :let [var1, var2] = mylist
 274
 275 変数の個数とリストの要素数が一致しないときはエラーになる。リストにある余分な要
 276 素をまとめて受け取るには、";"と受け取る変数名を書いておく: >
 277         :let [var1, var2; rest] = mylist
 278
 279 上の例は次とほぼ同じである: >
 280         :let var1 = mylist[0]
 281         :let var2 = mylist[1]
 282         :let rest = mylist[2:]
 283
 284 要素が 2 つしかないときでもエラーにはならない。"rest"は空リストになる。
 285
 286
 287 リストの変更 ~
 288                                                         *list-modification*
 289 リストの中の特定の要素を変更するには次のように|:let|を使う: >
 290         :let list[4] = "four"
 291         :let listlist[0][3] = item
 292
 293 始点と終点を指定してリストの一部分を変更することができる。代入する値は、少なく
 294 とも削除する範囲の要素数と同じ数だけ必要である: >
 295         :let list[3:5] = [3, 4, 5]
 296
 297 リストに要素を追加したり削除するには関数を使う。いくつか例を示す: >
 298         :call insert(list, 'a')         " 先頭に要素'a'を挿入する
 299         :call insert(list, 'a', 3)      " 要素'a'をlist[3]の前に挿入する
 300         :call add(list, "new")          " 文字列の要素を最後に追加する
 301         :call add(list, [1, 2])         " 1個の要素としてリストをを追加する
 302         :call extend(list, [1, 2])      " 2個の要素からなるリストを連結する
 303         :let i = remove(list, 3)        " 要素3を削除する
 304         :unlet list[3]                  " 同上
 305         :let l = remove(list, 3, -1)    " 要素3から最後までを削除する
 306         :unlet list[3 : ]               " 同上
 307         :call filter(list, 'v:val !~ "x"')  " 要素'x'を削除
 308
 309 要素の順番を変更する: >
 310         :call sort(list)                " リストをアルファベット順にソート
 311         :call reverse(list)             " 要素の順序を反転させる
 312
 313
 314 for ループ ~
 315
 316 |:for|ループは、1つの変数に対してリストの各要素を順番に代入し、コマンドを実行
 317 していく。例: >
 318         :for item in mylist
 319         :   call Doit(item)
 320         :endfor
 321
 322 上の例は次と同じ: >
 323         :let index = 0
 324         :while index < len(mylist)
 325         :   let item = mylist[index]
 326         :   :call Doit(item)
 327         :   let index = index + 1
 328         :endwhile
 329
 330 Note リストの全要素が同じ型でなければならない。そうでないとエラー|E706|にな
 331 る。ループの最後でループ変数を|:unlet|すれば、異なる型でも扱える。
 332
 333 やりたいことがリストの各要素を変更するだけなら、forループを使うより関数|map()|
 334 を使った方がよりシンプルになる。
 335
 336 |:let|コマンドと同じように、|:for|は変数のリストをループ変数にすることができる。
 337 この場合、引数はリストのリストでなければならない。 >
 338         :for [lnum, col] in [[1, 3], [2, 8], [3, 0]]
 339         :   call Doit(lnum, col)
 340         :endfor
 341
 342 これはリストの各要素に対して|:let|コマンドを実行するかのように実行される。また
 343 この場合も引数の型は全て同じでないとエラーになる。
 344
 345 引数の残りを1個のリスト変数に代入することもできる: >
 346         :for [i, j; rest] in listlist
 347         :   call Doit(i, j)
 348         :   if !empty(rest)
 349         :      echo "remainder: " . string(rest)
 350         :   endif
 351         :endfor
 352
 353
 354 リスト操作関数 ~
 355                                                 *E714*
 356 以下はリスト操作に使える関数である: >
 357         :let r = call(funcname, list)   " 引数リストをつけて関数を呼び出す
 358         :if empty(list)                 " リストが空かどうか判定する
 359         :let l = len(list)              " リストの要素数
 360         :let big = max(list)            " リスト中の最大値
 361         :let small = min(list)          " リスト中の最小値
 362         :let xs = count(list, 'x')      " 'x'の出現回数を数える
 363         :let i = index(list, 'x')       " 最初に'x'が現れる位置のインデックス
 364         :let lines = getline(1, 10)     " バッファから10行を取得
 365         :call append('$', lines)        " バッファに行を追加する
 366         :let list = split("a b c")      " 文字列を分割してリストにする
 367         :let string = join(list, ', ')  " リストの要素を連結して文字列にする
 368         :let s = string(list)           " リストの文字列表現
 369         :call map(list, '">> " . v:val')  " 各要素の前に">> "をつける
 370
 371 機能を組み合わせると、処理を単純に記述できることを覚えておくとよい。例えば、リ
 372 スト中の全ての数値の和を求める例: >
 373         :exe 'let sum = ' . join(nrlist, '+')
 374
 375
 376 1.4 辞書 ~
 377                                                 *Dictionaries* *Dictionary*
 378 辞書とは連想配列である。各要素はキーと値を持つ。要素はキーによって特定できる。
 379 要素は特に順序を持たずに保持される。
 380
 381
 382 辞書の作成 ~
 383                                                 *E720* *E721* *E722* *E723*
 384 辞書を作るには、{}の中にコンマで区切って要素を書く。各要素のキーと値はコロンで
 385 区切る。それぞれのキーは1度しか現れてはならない。例: >
 386         :let mydict = {1: 'one', 2: 'two', 3: 'three'}
 387         :let emptydict = {}
 388 <                                                       *E713* *E716* *E717*
 389 キーは必ず文字列である。数値を使うこともできるが、自動的に文字列に変換される。
 390 よって文字列'4'のキーと数値4のキーは同一の要素を参照する。
 391 entry.  Note 文字列'04'と数値04は異なることに注意。なぜなら数値04は文字列'4'に
 392 変換されるからである。
 393
 394 値はどんな式でもよい。辞書を値にすると、ネストした辞書ができる: >
 395         :let nestdict = {1: {11: 'a', 12: 'b'}, 2: {21: 'c'}}
 396
 397 最後の要素の後に余分なコンマがあると無視される。
 398
 399
 400 要素にアクセスする ~
 401
 402 通常、要素にアクセスするには[]の中にキーを書く: >
 403         :let val = mydict["one"]
 404         :let mydict["four"] = 4
 405
 406 また、この書き方で既存の辞書に要素を追加できる。この点はリストと異なる。
 407
 408 キー名がアルファベット、数字、アンダースコアだけからなる場合は、以下の形式が使
 409 える|expr-entry|: >
 410         :let val = mydict.one
 411         :let mydict.four = 4
 412
 413 要素はリストや辞書を含むどんな型でもよいため、インデックス参照とキー参照を続け
 414 て書くことができる: >
 415         :echo dict.key[idx].key
 416
 417
 418 辞書からリストへの変換 ~
 419
 420 辞書の全要素に対してループを行いたい場合がある。そのためには辞書をリストに変換
 421 し、そのリストに対して|:for|ループを行う。
 422
 423 多くの場合はキーに対してループを行う。これには関数|keys()|を使う: >
 424         :for key in keys(mydict)
 425         :   echo key . ': ' . mydict[key]
 426         :endfor
 427
 428 このキーのリストはソートされていない。ソートさせるには関数|sort()|を使う: >
 429         :for key in sort(keys(mydict))
 430
 431 値に対してループを行うには関数|values()|を使う: >
 432         :for v in values(mydict)
 433         :   echo "value: " . v
 434         :endfor
 435
 436 キーと値両方を得るには関数|items()|を使う。この関数は、キーと値の2個の要素から
 437 なるリストのリストを返す: >
 438         :for [key, value] in items(mydict)
 439         :   echo key . ': ' . value
 440         :endfor
 441
 442
 443 辞書の同一性 ~
 444                                                         *dict-identity*
 445 辞書のコピーを作るにはリストと同様に|copy()|と|deepcopy()|を使う必要がある。そ
 446 うでなく代入を行うと同一の辞書を参照するようになる: >
 447         :let onedict = {'a': 1, 'b': 2}
 448         :let adict = onedict
 449         :let adict['a'] = 11
 450         :echo onedict['a']
 451         11
 452
 453 2つの辞書は、全てのキー・値のペアが等しいとき等しいとみなされる。より詳しくは
 454 |list-identity|を参照。
 455
 456
 457 辞書の変更 ~
 458                                                         *dict-modification*
 459 辞書の要素を変更したり、新しい要素を追加するには|:let|を使う: >
 460         :let dict[4] = "four"
 461         :let dict['one'] = item
 462
 463 辞書から要素を取り除くには|remove()|か|:unlet|を使う。以下のように辞書からキー
 464 "aaa"を取り除くには3つの方法がある: >
 465         :let i = remove(dict, 'aaa')
 466         :unlet dict.aaa
 467         :unlet dict['aaa']
 468
 469 2つの辞書を併合させるには|extend()|を使う: >
 470         :call extend(adict, bdict)
 471 上のコマンドはbdictの全ての要素をadictに追加する。キーが重複した要素はbdictの
 472 要素により上書きされる。この動作は3番目の引数により変更できる。
 473 Note 辞書の要素間に順序は定まっていない。そのため":echo adict"としたとき、もと
 474 もとadictにあった要素が先に、bdictから追加された要素が後に表示されると考えては
 475 ならない。
 476
 477 辞書から条件を指定して要素を取り除くには|filter()|が使える: >
 478         :call filter(dict, 'v:val =~ "x"')
 479 このコマンドは"dict"から'x'にマッチしない要素を全て取り除く。
 480
 481
 482 関数を辞書に入れる ~
 483                                         *Dictionary-function* *self* *E725*
 484 関数が"dict"属性つきで定義されると、特殊な方法で呼び出すことができる。例: >
 485         :function Mylen() dict
 486         :   return len(self.data)
 487         :endfunction
 488         :let mydict = {'data': [0, 1, 2, 3], 'len': function("Mylen")}
 489         :echo mydict.len()
 490
 491 これはオブジェクト指向プログラミングのメソッドに似ている。この辞書の要素は
 492 |Funcref|である。暗黙に定義されるローカル変数"self"は、この関数を呼び出した辞
 493 書を参照している。
 494
 495 "dict"属性をつけないでFuncrefを辞書に入れることもできる。しかしその場合、変数
 496 "self"は定義されない。
 497
 498                                 *numbered-function* *anonymous-function*
 499 関数に名前をつける必要をなくすために、関数を定義して直接辞書に代入することがで
 500 きる: >
 501         :let mydict = {'data': [0, 1, 2, 3]}
 502         :function mydict.len() dict
 503         :   return len(self.data)
 504         :endfunction
 505         :echo mydict.len()
 506
 507 こうすると関数に番号がふられ、dict.lenがこの関数を参照する|Funcref|となる。こ
 508 の関数は|Funcref|を通してのみ呼び出せる。参照している|Funcref|がなくなると、こ
 509 の関数は自動的に削除される。
 510
 511 番号つき関数に必ずしも"dict"属性は必要ではない。
 512 訳注: It is not necessary to use the "dict" attribute for a numbered function.
 513
 514
 515 辞書操作関数 ~
 516                                                         *E715*
 517 以下は辞書操作に使える関数である: >
 518         :if has_key(dict, 'foo')        " 辞書がキー"foo"の要素を持つなら真
 519         :if empty(dict)                 " 辞書が空なら真
 520         :let l = len(dict)              " 辞書の要素数
 521         :let big = max(dict)            " 辞書中の最大値
 522         :let small = min(dict)          " 辞書中の最小値
 523         :let xs = count(dict, 'x')      " 'x'の出現回数を数える
 524         :let s = string(dict)           " 辞書の文字列表現
 525         :call map(dict, '">> " . v:val')  " 各要素の前に">> "をつける
 526
 527
 528 1.5 変数について補足 ~
 529                                                         *more-variables*
 530
 531 変数や式の結果の型を知りたいのならば、関数|type()|を使う。
 532
 533 オプション'viminfo'にフラグ'!'が含まれるならば、大文字で始まり小文字を含まない
 534 名前のグローバル変数は、viminfoファイル|viminfo-file|に格納される。
 535
 536 オプション'sessionoptions'が"global"を含むなら、大文字で始まり少なくとも一文字
 537 以上の小文字を含む名前のグローバル変数は、sessionファイル|session-file|に格納
 538 される。
 539
 540 変数名                     何処に保存されるか ~
 541 my_var_6                されない
 542 My_Var_6                sessionファイル
 543 MY_VAR_6                viminfoファイル
 544
 545
 546 波括弧を使って変数名を構成できる。詳細は|curly-braces-names|を参照。
 547
 548 ==============================================================================
 549 2. 式の文法                                         *expression-syntax*
 550
 551 式文法一覧、優先順位の低いものから高い順に:
 552
 553 |expr1| expr2 ? expr1 : expr1   if-then-else 条件式
 554
 555 |expr2| expr3 || expr3 ..       論理和
 556
 557 |expr3| expr4 && expr4 ..       論理積
 558
 559 |expr4| expr5 == expr5          等しい
 560         expr5 != expr5          等しくない
 561         expr5 >  expr5          より大きい
 562         expr5 >= expr5          大きいか等しい
 563         expr5 <  expr5          より小さい
 564         expr5 <= expr5          小さいか等しい
 565         expr5 =~ expr5          正規表現にマッチする
 566         expr5 !~ expr5          正規表現にマッチしない
 567
 568         expr5 ==? expr5         文字列として等しい(大文字/小文字区別無し)
 569         expr5 ==# expr5         文字列として等しい(大文字/小文字区別有り)
 570         etc.                    上記の各式は大小文字の区別を、?を付加すると行
 571                                 わず、#を付加すると行う
 572
 573         expr5 is expr5          同一の |List| のインスタンス
 574         expr5 isnot expr5       異なる |List| のインスタンス
 575
 576 |expr5| expr6 +  expr6 ..       足し算またはリストの連結
 577         expr6 -  expr6 ..       引き算
 578         expr6 .  expr6 ..       文字列の連結
 579
 580 |expr6| expr7 *  expr7 ..       掛け算
 581         expr7 /  expr7 ..       割り算
 582         expr7 %  expr7 ..       剰余(割った余り)
 583
 584 |expr7| ! expr7                 論理否定
 585         - expr7                 単項のマイナス(訳注:-1等)
 586         + expr7                 単項のプラス
 587
 588 |expr8| expr8[expr1]            文字列のバイト、またはリストの要素
 589         expr8[expr1 : expr1]    文字列の部分文字列、またはリストの部分リスト
 590         expr8.name              辞書 |Dictionary| の要素
 591         expr8(expr1, ...)       |Funcref| 変数による関数呼び出し
 592
 593 |expr9| number                  数定数
 594         "string"                文字列定数。バックスラッシュは特別な意味を持つ
 595         'string'                リテラル文字列定数。'を含めるには2重にする
 596         [expr1, ...]            リスト |List|
 597         {expr1: expr1, ...}     辞書 |Dictionary|
 598         &option                 オプション変数
 599         (expr1)                 式の入れ子
 600         variable                内部変数
 601         va{ria}ble              波括弧付きの内部変数
 602         $VAR                    環境変数
 603         @r                      レジスタ'r'の値
 604         function(expr1, ...)    関数呼出し
 605         func{ti}on(expr1, ...)  波括弧付きの内部変数
 606
 607 ".." はその演算が、その後に他の演算を続ける事が出来ることを示している。
 608 例: >
 609         &nu || &list && &shell == "csh"
 610
 611 一つのレベルにある全ての式は左から右に解釈される。
 612
 613
 614 expr1                                                   *expr1* *E109*
 615 -----
 616
 617 expr2 ? expr1 : expr1
 618
 619 '?'より前の式は数値として評価される。その結果が非0であった場合、'?'と':'に挟ま
 620 れた式の値がこの式全体の値となり、逆に0であった場合は':'以降の式の値が全体の値
 621 となる。
 622 例: >
 623         :echo lnum == 1 ? "先頭" : lnum
 624
 625 始めの式が"expr2"であるから、そこに別の?:を含むことはできない。残り二つの式に
 626 ついては以下のように再帰的な?:の利用が許される。
 627 例: >
 628         :echo lnum == 1 ? "top" : lnum == 1000 ? "last" : lnum
 629
 630 読み易くするために、行継続|list-continuation|を利用することが推奨される: >
 631         :echo lnum == 1
 632         :\      ? "top"
 633         :\      : lnum == 1000
 634         :\              ? "last"
 635         :\              : lnum
 636
 637 ':'の前には必ずスペースを入れること。そうでないと"a:1"のような変数の使用と間違
 638 えてしまう可能性がある。
 639
 640
 641 expr2 and expr3                                         *expr2* *expr3*
 642 ---------------
 643
 644                                                 *expr-barbar* *expr-&&*
 645 演算子"||"と"&&"は左右に一つずつ引数を取る。引数は数値に変換される。結果は:
 646
 647           入力                               出力               ~
 648 n1              n2              n1 || n2        n1 && n2    ~
 649 零               零               零               零
 650 零               非零              非零              零
 651 非零              零               非零              零
 652 非零              非零              非零              非零
 653
 654 演算子は続けて書く事ができる。例: >
 655
 656         &nu || &list && &shell == "csh"
 657
 658 Note "&&"は"||"よりも高い優先順位を持っている。これは次の事を意味する: >
 659
 660         &nu || (&list && &shell == "csh")
 661
 662 結果が確定した時点で残りの式は省略され、解釈されない。これはC言語で行なわれる
 663 ことに似ている。例: >
 664
 665         let a = 1
 666         echo a || b
 667
 668 これはaが非零で戻り値は絶対に非零であるから、変数bが宣言されていなくても有効で
 669 ある。次のも同様に: >
 670
 671         echo exists("b") && b == "yes"
 672
 673 これもbが宣言されているいないに関わらず有効である。後半の項はbが定義されている
 674 時にだけ評価される。
 675
 676
 677 expr4                                                   *expr4*
 678 -----
 679
 680 expr5 {cmp} expr5
 681
 682 2つの式expr5を比較し、結果が偽なら0を、真なら1を返す。
 683
 684                                 *expr-==*  *expr-!=*  *expr->*   *expr->=*
 685                                 *expr-<*   *expr-<=*  *expr-=~*  *expr-!~*
 686                                 *expr-==#* *expr-!=#* *expr->#*  *expr->=#*
 687                                 *expr-<#*  *expr-<=#* *expr-=~#* *expr-!~#*
 688                                 *expr-==?* *expr-!=?* *expr->?*  *expr->=?*
 689                                 *expr-<?*  *expr-<=?* *expr-=~?* *expr-!~?*
 690                                 *expr-is*
 691                 'ignorecase'次第   大小文字考慮    大小文字無視 ~
 692 等しい                     ==              ==#             ==?
 693 等しくない           !=              !=#             !=?
 694 より大きい           >               >#              >?
 695 より大きいか等しい       >=              >=#             >=?
 696 より小さい           <               <#              <?
 697 より小さいか等しい       <=              <=#             <=?
 698 正規表現マッチ         =~              =~#             =~?
 699 正規表現非マッチ        !~              !~#             !~?
 700 同一のインスタンス       is
 701 異なるインスタンス       isnot
 702
 703 例:
 704 "abc" ==# "Abc"   0と評価される
 705 "abc" ==? "Abc"   1と評価される
 706 "abc" == "Abc"    'ignorecase'が設定されていれば1と、でなければ0と評価
 707
 708                                                         *E691* *E692*
 709 リスト|List|はリストとだけ比較可能で、==系、!=系、is、isnotのみ利用できる。
 710 これらはそれぞれのリストの値を再帰的に比較する。大文字小文字無視にすると要素を
 711 比較するときに大文字小文字を無視する。
 712
 713                                                         *E735* *E736*
 714 辞書|Dictionary|は辞書とだけ比較可能で、==系、!=系、is、isnotのみ利用できる。
 715 これらは辞書のキー/値を再帰的に比較する。大文字小文字無視にすると要素を
 716 比較するときに大文字小文字を無視する。
 717
 718                                                         *E693* *E694*
 719 |Funcref|は|Funcref|とだけ比較可能で、"equal"と"not equal"のみ利用できる。大文
 720 字小文字は常に区別される。
 721
 722 リスト|List|に対して"is"や"isnot"を使うと、それらの式が同じリストのインスタン
 723 スを参照しているか判定される。リストのコピーと元のリストは異なると判定される。
 724 リスト以外に対して"is"は"equal"と同じで、"isnot"は"not equal"と同じである。た
 725 だし"is"、"isnot"は型が異なると値が等しくない点が"=="とは異なる。「4 == '4'」
 726 は真で、「4 is '4'」は偽である。
 727
 728 文字列と数値を比較した場合、文字列が数値に変換され、数値として比較される。これ
 729 は"0 == 'x'"が、'x'が数値としては0であることから、真となることを意味する。
 730
 731 文字列同士を比較した場合、strcmp()やstricmp()によって比較される。これは数値的
 732 に(バイトの値で)比較されるのであって、必ずしも言語に基づく文字種の違いではな
 733 い。
 734
 735 '#'を付けた演算子を使うか、省略形かつ'ignorecase'が設定されていない場合、比較
 736 はstrcmp()で行なわれる。大文字・小文字は区別される。
 737
 738 '?'を付けた演算子を使うか、省略形かつ'ignorecase'が設定されている場合、比較は
 739 stricmp()で行なわれる。大文字・小文字は区別されない。
 740
 741 'smartcase' は適用されない。
 742
 743 "=~"と"!~"演算子は右側の引数を正規表現のパターンとして、左側の引数に対してマッ
 744 チを試みる。正規表現のパターンに関しては|pattern|を参照。このマッチは'magic'が
 745 設定され'cpoptions'が空であるように振舞い、実際の'magic'や'cpoptions'に何が設
 746 定されているには依存しない。これがスクリプトをポータブルにしてくれる。正規表現
 747 中のバックスラッシュが重複してしまうのを避けるには、シングルクォーテーションの
 748 文字列を使用する。詳細は|literal-string|を参照。
 749 文字列は単一行として扱われるので、複数行のパターン(\nを含むもの)はマッチしな
 750 い。しかしながらリテラルなヌル文字(NL)を、普通の文字として代用することはでき
 751 る。例:
 752         "foo\nbar" =~ "\n"      1として評価される
 753         "foo\nbar" =~ "\\n"     0として評価される
 754
 755
 756 expr5 and expr6                                         *expr5* *expr6*
 757 ---------------
 758 expr6 +  expr6 ..       足し算、またはリストの連結   *expr-+*
 759 expr6 -  expr6 ..       引き算                             *expr--*
 760 expr6 .  expr6 ..       文字列の連結                  *expr-.*
 761
 762 リストに対しては"+"のみ可能で、expr6は両方ともリストでなければならない。結果は
 763 2つのリストを連結した新しいリスト。
 764
 765 expr7 *  expr7 ..       掛け算                             *expr-star*
 766 expr7 /  expr7 ..       割り算                             *expr-/*
 767 expr7 %  expr7 ..       剰余(割った余り)               *expr-%*
 768
 769 "."を除く全ての演算子は自動的に文字列を数値に変換する。
 770
 771 "+"と"."の違いに注意:
 772         "123" + "456" = 579
 773         "123" . "456" = "123456"
 774
 775 '.' は '+' と '-' と等しい優先順位を持つので、次の式は: >
 776         1 . 90 + 90.0
 777 次のように解釈される: >
 778         (1 . 90) + 90.0
 779 これはエラーにならない。というのは、"190" は自動的に数値 190 に変換さ
 780 れ、それと浮動小数点数 90.0 との和になる。しかし次の式は: >
 781         1 . 90 * 90.0
 782 次のように解釈される: >
 783         1 . (90 * 90.0)
 784 '.' は '*' より優先順位が低いためである。これはエラーになる。というのは、浮動
 785 小数点数と文字列を結合することになるからである。
 786
 787 数値をゼロで割った結果は、被除数によって次のようになる:
 788           0 / 0  = -0x80000000  (浮動小数点数の NaN のようなもの)
 789          >0 / 0  =  0x7fffffff  (正の無限大のようなもの)
 790          <0 / 0  = -0x7fffffff  (負の無限大のようなもの)
 791         (訳注: >0 は正の数、<0 は負の数の意味)
 792         (Vim 7.2 以前では常に 0x7fffffff だった)
 793
 794 '/'の右辺(除数)が0の場合、結果は0x7ffffffになる。
 795 '%'の右辺(法)が0の場合、結果は0になる。
 796
 797 これらは全て|Funcref|には適用できない。
 798
 799 . と % は浮動小数点数には適用できない。 *E804*
 800
 801
 802 expr7                                                   *expr7*
 803 -----
 804 ! expr7                 論理否定            *expr-!*
 805 - expr7                 単項マイナス          *expr-unary--*
 806 + expr7                 unary plus              *expr-unary-+*
 807
 808 '!'演算子では非零は0に、0は1になる。
 809 '-'では数値の符号が反転される。
 810 '+"では変化はない。
 811
 812 文字列はまず数値に変換される。
 813
 814 これら2つは繰り返したり混ぜたりできる。例:
 815         !-1         == 0
 816         !!8         == 1
 817         --9         == 9
 818
 819
 820 expr8                                                   *expr8*
 821 -----
 822 expr8[expr1]            文字列またはリストの要素    *expr-[]* *E111*
 823
 824 expr8が数値か文字列ならば、この値は文字列 expr8 の第 expr1 番目のバイトからな
 825 る 1 バイトの文字列となる。expr8は文字列、expr1は数として扱われる。ただし
 826 expr8 がマルチバイト文字列である場合、この値は単なるバイトコードであり、1文字
 827 とはならないかもしれないことに注意。マルチバイト文字列に対する代替方法は
 828 |byteidx()| を参照。
 829
 830 インデックスが0の場合、先頭のキャラクタが得られることに注意。これはC言語のよう
 831 に働く。注意:カラム番号は1から始まる。例えばカーソルの下の文字を得るためには、
 832 次のようにする必要がある: >
 833         :let c = getline(".")[col(".") - 1]
 834
 835 文字列の長さよりも大きなインデックスが指定された場合、結果は空文字列になる。負
 836 数のインデックスを指定すると、結果は常に空文字列になる(後方互換性のため)。
 837 最後のバイトを得るには[-1:]を使うこと。
 838
 839 expr8がリスト|List|ならばインデックスexpr1の要素が返る。取りうるインデックスの
 840 値については|list-index|を参照。インデックスが範囲を超えている場合はエラーとな
 841 る。例: >
 842         :let item = mylist[-1]          " 最後の要素を取得
 843
 844 一般的には、インデックスが正でリストの長さ以上または、負でリストの長さ×-1より
 845 小さいときエラーとなる。
 846
 847
 848 expr8[expr1a : expr1b]  部分文字列または部分リスト   *expr-[:]*
 849
 850 expr8が数値か文字列ならば、expr1aバイトからexpr1bバイトまでの部分文字列となる
 851 (両端を含む)。expr8は文字列として扱われ、expr1aとexpr1bは数値として扱われる。
 852 Note マルチバイトのエンコーディングは認識しない。マルチバイト文字列のイン
 853 デックスを計算する方法については |byteidx()| を参照。
 854
 855 expr1aが省略されたときは0となる。expr1bが省略されたときは文字列の長さ-1となる。
 856
 857 負数のインデックスを使うことによって文字列の末尾から取り出すことができる。-1は
 858 最後の文字、-2は最後から2文字目…を表す。
 859
 860 インデックスがその文字の範囲外に出てしまったときは、その文字は省かれる。expr1b
 861 がexpr1aより小さいときは空文字列となる。
 862
 863 例: >
 864         :let c = name[-1:]              " 文字列の最後のバイト
 865         :let c = name[-2:-2]            " 文字列の最後から2バイト目
 866         :let s = line(".")[4:]          " 5バイト目から末尾まで
 867         :let s = s[:-3]                 " 最後の2文字を削除する
 868 <
 869                                                         *sublist* *slice*
 870 expr8がリストならば、インデックスexpr1aとexpr1bの間の要素からなる新しいリスト
 871 となる。上で説明した文字列の場合と同様だが、インデックスが範囲を超えるとエラー
 872 になる。例: >
 873         :let l = mylist[:3]             " 最初の4個の要素
 874         :let l = mylist[4:4]            " 1個の要素からなるリスト
 875         :let l = mylist[:]              " リストの浅いコピー
 876
 877 |Funcref|に対してexpr8[expr1]やexpr8[expr1a : expr1b]を使うとエラーになる。
 878
 879
 880 expr8.name              辞書|Dictionary|の要素               *expr-entry*
 881
 882 expr8が辞書|Dictionary|のとき、ドットをつけるとその後に書かれた名前が辞書のキ
 883 ーと見なされる。例: expr8[name]。
 884
 885 名前は変数名と同じようにアルファベットと数字だけから構成されなければならない
 886 が、数字で始まってもよい。波括弧は使えない。
 887
 888 ドットの前後に空白があってはならない。
 889
 890 例: >
 891         :let dict = {"one": 1, 2: "two"}
 892         :echo dict.one
 893         :echo dict .2
 894
 895 Note ドットは文字列連結にも使われる。混乱を避けるために、文字列連結のドットの
 896 周りには必ずスペースを入れること。
 897
 898
 899 expr8(expr1, ...)       |Funcref| 関数呼び出し
 900
 901 expr8が|Funcref|型の変数のとき、その参照する関数を呼び出す。
 902
 903
 904
 905                                                         *expr9*
 906 数
 907 ------
 908 number                  数定数                     *expr-number*
 909
 910 10進数、16進数(0xか0Xで始まる)、もしくは8進数(0で始まる)の数定数。
 911
 912                                                 *floating-point-format*
 913 浮動小数点数は次の2つの形式で書ける:
 914
 915         [-+]{N}.{M}
 916         [-+]{N}.{M}e[-+]{exp}
 917
 918 ここで {N} と {M} は数値である。{N} と{M} の両方とも省略してはなら
 919 ず、数値のみを含めることができる。
 920 [-+] は、省略可能なプラスまたはマイナス記号である。
 921 {exp} は指数で、10 のベキ。
 922 現在のロケールが何であれ、小数点にはドットのみを使える。コンマは使えない。
 923 {|+float| 機能つきでコンパイルされたときのみ有効}
 924
 925 例:
 926         123.456
 927         +0.0001
 928         55.0
 929         -0.123
 930         1.234e03
 931         1.0E-6
 932         -3.1416e+88
 933
 934 次のものは無効である:
 935         3.              empty {M}
 936         1e40            missing .{M}
 937
 938                                                         *float-pi* *float-e*
 939 コピー＆ペーストしておくのに便利な値: >
 940 A few useful values to copy&paste: >
 941         :let pi = 3.14159265359
 942         :let e  = 2.71828182846
 943
 944 論理的根拠:
 945 浮動小数点数が導入される前は、123.456 と書くと 123 と 456 の2つの数値と解釈
 946 され、それらが文字列に変換されて結合されて "123456" という文字列になった。
 947 これは無意味であり、Vim スクリプト内で意図的に使われているものが見つからな
 948 かったので、浮動小数点数の普通の表記法を用いるため、この後方非互換性は許容され
 949 た。
 950
 951                                                 *floating-point-precision*
 952 浮動小数点数の精度と範囲は、Vim とリンクしたライブラリの "double" の意味によ
 953 る。実行時にこれを変更することはできない。
 954
 955 浮動小数点数 |Float| は printf("%g, f) とするのと同様に、小数点以下6桁まで表示
 956 される。表示する桁数は |printf()| を使えば変えられる。例: >
 957         :echo printf('%.15e', atan(1))
 958 <       7.853981633974483e-01
 959
 960
 961
 962 文字列                                                     *expr-string* *E114*
 963 ------
 964 "string"                文字列定数           *expr-quote*
 965
 966 ダブルクォートが使われていることに注意。
 967
 968 文字列定数には以下の特殊文字が使用できる:
 969 \...    3桁の8進数字 (例 "\316")
 970 \..     2桁の8進数字 (非数字が続かなければならない)
 971 \.      1桁の8進数字 (非数字が続かなければならない)
 972 \x..    2桁の16進数字 (例 "\x1f")
 973 \x.     1桁の16進数字 (16進数字でないものが続かなければならない)
 974 \X..    \x..に同じ
 975 \X.     \x.に同じ
 976 \u....  文字を4桁の16進数で表現したもので、実際の値は現在の'encoding'の値に依
 977         存する (例えば "\u02a4")
 978 \U....  \u....に同じ
 979 \b      バックスペース <BS>
 980 \e      エスケープ <Esc>
 981 \f      フォームフィード <FF>
 982 \n      改行 <NL>
 983 \r      改行(キャリッジリターン) <CR>
 984 \t      タブ <Tab>
 985 \\      円記号(バックスラッシュ)
 986 \"      ダブルクォート
 987 \<xxx>  "xxx"という名の特殊キー。 例 "\<C-W>" は CTRL-W.
 988
 989 Note "\xff"は値255の1バイトとなる。これはエンコーディングによっては無効な値か
 990 もしれない。現在の'encoding'の値に応じた文字255を得るには"\u00ff"を使う。
 991
 992 Note "\000"と"\x00"は強制的に文字列の終端として扱われる。
 993
 994
 995 リテラル文字列                                         *literal-string* *E115*
 996 ---------------
 997 'string'                文字列定数           *expr-'*
 998
 999 Note シングルクォートが使われていることに注意。
1000
1001 この文字列は文字通りに扱われる。バックスラッシュは取り除かれないし、また特別な
1002 意味を持ったりもしない。唯一の例外は、2つのシングルクォートで1つのシングルクォ
1003 ートになることである。
1004
1005 シングルクォートの文字列は、バックスラッシュを2重にしなくてよいため、正規表現
1006 パターンを表すのに便利である。以下の2つのコマンドは同値である: >
1007         if a =~ "\\s*"
1008         if a =~ '\s*'
1009
1010
1011 オプション                                   *expr-option* *E112* *E113*
1012 ------
1013 &option                 オプション変数、ローカルなものが優先
1014 &g:option               グローバルオプション変数
1015 &l:option               ローカルオプション変数
1016
1017 例: >
1018         echo "タブストップは " . &tabstop . " です"
1019         if &insertmode
1020
1021 ここにはあらゆるオプション名を使うことができる。|options|を参照。ローカル変数
1022 を使おうとして、実際にはバッファローカルもウィンドウローカルも存在しない場合に
1023 は、グローバル変数が利用される。
1024
1025
1026 レジスタ                                            *expr-register* *@r*
1027 --------
1028 @r                      レジスタ'r'の値
1029
1030 名前付きレジスタの中身を1つの文字列として得る。必要なところには改行文字が挿入
1031 されている。無名レジスタの中身を取得するには@"か@@を使う。利用可能なレジスタの
1032 説明については|registers|を参照。
1033
1034 レジスタ'='を使うと、式の値でなく式そのものを得る。それを評価するには|eval()|
1035 を使う。
1036
1037
1038 入れ子                                                     *expr-nesting* *E110*
1039 -------
1040 (expr1)                 式の入れ子
1041
1042
1043 環境変数                                            *expr-env*
1044 --------------------
1045 $VAR                    環境変数
1046
1047 環境変数の文字列。定義されていない環境変数を指定した場合、結果は空文字列。
1048                                                         *expr-env-expand*
1049 Note $VARを直接使用した場合とexpand("$VAR")を使用した場合では、動作に違いがあ
1050 ることに注意。直接使用した場合には、現在のVimのセッション中で既知の値に展開さ
1051 れるだけである。expand()を使用した場合、まず最初にVimのセッション中で既知の値
1052 に展開される。それが失敗した場合、変数の展開にシェルが使用されることになる。こ
1053 れは遅くはなるが、シェルの知りうる総ての変数を展開することができる。例: >
1054         :echo $version
1055         :echo expand("$version")
1056 最初の一つは恐らく何も返ってこず、2つ目は$versionの値が返ってくるだろう(貴方の
1057 シェルがサポートしていたとして)
1058
1059
1060 内部変数                                            *expr-variable*
1061 -----------------
1062 variable                内部変数
1063 以下の|internal-variables|を参照。
1064
1065
1066 関数呼出            *expr-function* *E116* *E118* *E119* *E120*
1067 -------------
1068 function(expr1, ...)    関数呼出
1069 以下の|functions|を参照。
1070
1071
1072 ==============================================================================
1073 3. 内部変数                                 *internal-variables* *E121*
1074                                                                         *E461*
1075 内部変数の名前には文字と、数字とアンダーバー('_')を使うことができる。しかし数
1076 字で始めることはできない。波括弧を使うこともできる。
1077 詳細は|curly-braces-names|を参照。
1078
1079 内部変数は":let"コマンドで作成される|:let|。":unlet"コマンドで明示的に内部変数
1080 を破棄することができる|:unlet|。内部変数に使われてない名前か、既に破棄された内
1081 部変数を使うとエラーとなる。
1082
1083 変数には幾つもの名前空間が存在する。実際にどれが利用されるかは、どのような前置
1084 子が使われたかで決まる:
1085
1086                 (無し) 関数の中では関数ローカル、それ以外ではグローバル
1087 |buffer-variable|    b:   現在のバッファにローカル
1088 |window-variable|    w:   現在のウィンドウにローカル
1089 |tabpage-variable|   t:   現在のタブページにローカル
1090 |global-variable|    g:   グローバル
1091 |local-variable|     l:   関数にローカル
1092 |script-variable|    s:   |:source|されたVimスクリプトにローカル
1093 |function-argument|  a:   関数の引数(関数内のみ)
1094 |vim-variable|       v:   グローバル、Vimがあらかじめ定義
1095
1096 これらのスコープそのものに辞書を通じてアクセスできる。例えば、全てのスクリプト
1097 ローカル変数を削除するには次のようにする: >
1098         :for k in keys(s:)
1099         :    unlet s:[k]
1100         :endfor
1101 <
1102                                                 *buffer-variable* *b:var*
1103 "b:"で始まる変数名は、カレントバッファに局所的な変数を意味する。このように一つ
1104 一つのバッファ毎に、変数"b:foo"を別々に使用することができる。この種の変数は
1105 バッファが掃除(wipe out)された時や、":bdelete"で削除された時に一緒に削除され
1106 る。
1107
1108 1つのバッファローカル変数が定義済:
1109                                         *b:changedtick-variable* *changetick*
1110 b:changedtick   現在のバッファに対する総変更の回数。変更を行うたびに増加する。
1111                 これには一回のアンドゥ操作もカウントされる。この変数はバッファ
1112                 に変更が行われた際にだけアクションを起こしたい時に利用できる。
1113                 例: >
1114                     :if my_changedtick != b:changedtick
1115                     :   let my_changedtick = b:changedtick
1116                     :   call My_Update()
1117                     :endif
1118 <
1119                                                 *window-variable* *w:var*
1120 "w:"で始まる変数名は、カレントウィンドウにローカルな変数を意味する。これはウィ
1121 ンドウを閉じるときに破棄される。
1122
1123                                                 *tabpage-variable* *t:var*
1124 "t:"で始まる変数名は、カレントタブページにローカルな変数を意味する。これはタブ
1125 ページを閉じるときに破棄される。{+windows 機能つきでコンパイルしたときのみ利用
1126 可能}
1127
1128                                                 *global-variable* *g:var*
1129 関数の中からグローバル変数へアクセスするには、"g:"を付けた名前を使用する。これ
1130 が省略された場合は関数ローカルな変数にアクセスする。ただし"g:"自体は、関数の外
1131 でも使うことができる。
1132
1133                                                 *local-variable* *l:var*
1134 関数の中からそのローカル変数にアクセスするには何も前置しなければ良い。明示的に
1135 "l:"を付けることも可能である。ただし"l:"をつけないと予約されている変数名と衝突
1136 してしまうことがある。例: "count"とすると"v:count"を参照してしまう。"l:count"
1137 とすればローカル変数countを参照できる。
1138
1139                                                 *script-variable* *s:var*
1140 Vimスクリプト内では"s:"で始まる変数名を使うことができる。これはスクリプトにつ
1141 いてローカルであり、スクリプトの外部からはアクセスできない。
1142
1143 スクリプトローカル関数は次の中で使われる:
1144 - そのスクリプトをsourceしている間に実行されるコマンド
1145 - そのスクリプト内で定義される関数
1146 - そのスクリプト内で定義されるオートコマンド
1147 - そのスクリプト内で定義される関数やオートコマンドで定義される関数やオートコマ
1148   ンド(再帰的)
1149 - そのスクリプト内で定義されるユーザ定義コマンド
1150 次の場面では使えない:
1151 - そのスクリプトからsourceされる他のスクリプト
1152 - マッピング
1153 - メニュー
1154 - など。
1155
1156 グローバル変数との衝突を避けるにはスクリプト変数を使う。
1157 次の例を参照: >
1158
1159         let s:counter = 0
1160         function MyCounter()
1161           let s:counter = s:counter + 1
1162           echo s:counter
1163         endfunction
1164         command Tick call MyCounter()
1165
1166 ここで他のスクリプトから"Tick"を実行してみると、そのスクリプト内の変数
1167 "s:counter"は変化せず、"Tick"が定義されたスクリプト内の"s:counter"だけが変化す
1168 る。
1169
1170 これと同じことをするもう1つの例: >
1171
1172         let s:counter = 0
1173         command Tick let s:counter = s:counter + 1 | echo s:counter
1174
1175 関数呼び出しやユーザ定義コマンドを実行するとき、スクリプト変数のコンテキストは
1176 その関数、コマンドが定義されたスクリプトとなる。
1177
1178 関数の中で関数を定義した場合、スクリプト変数も共有される。例: >
1179
1180         let s:counter = 0
1181         function StartCounting(incr)
1182           if a:incr
1183             function MyCounter()
1184               let s:counter = s:counter + 1
1185             endfunction
1186           else
1187             function MyCounter()
1188               let s:counter = s:counter - 1
1189             endfunction
1190           endif
1191         endfunction
1192
1193 このStartCounting()を呼ぶと、カウントアップかカウントダウンのどちらかを行う関
1194 数MyCounter()を定義する。StartCounting()がどこで呼ばれたかに関係なく、
1195 MyCounter()の中では変数s:counterにアクセスできる。
1196
1197 同じスクリプトが再度読み込まれた場合、同一のスクリプト変数が使われる。スクリプ
1198 ト変数はVimが終了するまで存続する。以下の例はカウンタを保持する: >
1199
1200         if !exists("s:counter")
1201           let s:counter = 1
1202           echo "script executed for the first time"
1203         else
1204           let s:counter = s:counter + 1
1205           echo "script executed " . s:counter . " times now"
1206         endif
1207
1208 Note これはつまり、ファイルタイププラグインはバッファごとにスクリプト変数を1セッ
1209 ト持つのではないということを意味する。そのような目的にはバッファローカル変数
1210 |b:var|を使うこと。
1211
1212
1213 Vimの定義済変数:                              *vim-variable* *v:var*
1214
1215                                         *v:beval_col* *beval_col-variable*
1216 v:beval_col     マウスポインタがある桁の桁番号。|v:beval_lnum|行目のバイトイン
1217                 デックスである。オプション'balloonexpr'を評価している最中のみ
1218                 有効。
1219
1220                                         *v:beval_bufnr* *beval_bufnr-variable*
1221 v:beval_bufnr   マウスポインタがあるバッファの番号。オプション'balloonexpr'を
1222                 評価している最中のみ有効。
1223
1224                                         *v:beval_lnum* *beval_lnum-variable*
1225 v:beval_lnum    マウスポインタがある行の行番号。オプション'balloonexpr'を
1226                 評価している最中のみ有効。
1227
1228                                         *v:beval_text* *beval_text-variable*
1229 v:beval_text    マウスポインタの下もしくは後ろにあるテキスト。Cプログラムのデ
1230                 バッグのために有用。'iskeyword'が適用されるが、マウスポインタ
1231                 の下より前にあるドットと"->"は含まれる。マウスポインタが']'の
1232                 上にあるときは、そこから対応する'['とその前にあるテキストまで
1233                 が含まれる。マウスポインタが1行に収まるビジュアル領域の上にあ
1234                 るときはその選択領域となる。オプション'balloonexpr'を評価して
1235                 いる最中のみ有効。
1236
1237                                         *v:beval_winnr* *beval_winnr-variable*
1238 v:beval_winnr   マウスポインタがあるウィンドウの番号。オプション'balloonexpr'
1239                 を評価している最中のみ有効。
1240
1241                                         *v:char* *char-variable*
1242 v:char          'formatexpr'を評価しているときの引数。また、短縮入力 |map-<expr>|
1243                 で <expr> を指定しているとき、タイプされた文字を保持する。
1244
1245                         *v:charconvert_from* *charconvert_from-variable*
1246 v:charconvert_from
1247                 変換しようとしているファイルの文字エンコーディング名。オプショ
1248                 ン'charconvert'を評価している最中のみ有効。
1249
1250                         *v:charconvert_to* *charconvert_to-variable*
1251 v:charconvert_to
1252                 変換後のファイルの文字エンコーディング名。オプション
1253                 'charconvert'を評価している最中のみ有効。
1254
1255                                         *v:cmdarg* *cmdarg-variable*
1256 v:cmdarg        2つの目的のために使われる:
1257                 1. ファイルの読み書きコマンドに与えられる余分な引数。現在のと
1258                    ころ"++enc="と"++ff="がそれである。読み書きコマンドに対する
1259                    オートコマンドイベントが発生する前にこの変数が代入される。
1260                    その読み書きコマンドの後に直接この変数を連結できるように、
1261                    先頭にスペースがついている。Note: ここには"+cmd"引数は含ま
1262                    れていない。どちらにしろそれは実行されるからである。
1263                 2. ":hardcopy"でPostScriptファイルを印刷するとき、これが
1264                    ":hardcopy"への引数になる。'printexpr'の中で使うことができ
1265                    る。
1266
1267                                         *v:cmdbang* *cmdbang-variable*
1268 v:cmdbang       v:cmdargと同じく読み書きコマンドを実行したとき設定される。読み
1269                 書きコマンドに"!"が使われたときは1となり、使われていなければ0
1270                 となる。Note オートコマンドの中でのみ利用可能なことに注意。ユー
1271                 ザ定義コマンドでは|<bang>|を使えば同じことができる。
1272
1273                                         *v:count* *count-variable*
1274 v:count         最後に実行されたノーマルモードコマンドに渡されたコマンドの実行
1275                 回数を返す。読出し専用。使用例: >
1276         :map _x :<C-U>echo "the count is " . count<CR>
1277 <               Note: <C-U>は、カウントの後に':'をタイプした時に示される、行範
1278                 囲指定を削除するために必要となる。
1279                 "3d2w" のようにカウントが2個指定された場合、その数が掛けられる。
1280                 よって "d6w" となる。
1281                 オプション'formatexpr'を評価するためにも使われる。
1282                 また"count"は、以前の版のVimとの互換性の為に動作する。
1283
1284                                         *v:count1* *count1-variable*
1285 v:count1        "v:count"と同じように、しかしカウントが指定されなかった時の省
1286                 略値として存在する。
1287
1288                                                 *v:ctype* *ctype-variable*
1289 v:ctype         文字に関する実行環境の現在のロケール設定。これを使えばVim
1290                 スクリプト内で現在のロケール設定に対応できるようになる。技術的
1291                 な詳細: LC_CTYPEに等しい。ロケールを使用していないときは"C"に
1292                 なる。
1293                 この変数を設定するには|:language|コマンドを使うこと。直接設定
1294                 することはできない。
1295                 |multi-lang|を参照。
1296
1297                                         *v:dying* *dying-variable*
1298 v:dying         通常時は0。致命的なシグナルを受信したとき1が代入される。複数
1299                 のシグナルを受信すると値が増加していく。オートコマンド内でVim
1300                 が正常に終了するかチェックするために使える。{Unix でのみ動作}
1301                 例: >
1302         :au VimLeave * if v:dying | echo "\nAAAAaaaarrrggghhhh!!!\n" | endif
1303 <
1304                                         *v:errmsg* *errmsg-variable*
1305 v:errmsg        最後に表示されたエラーメッセージ。この変数は代入することが許
1306                 されている。例: >
1307         :let errmsg = ""
1308         :next
1309         :if (errmsg != "")
1310         :  ...
1311 <               また"errmsg"は、以前の版のVimとの互換性の為に動作する。
1312
1313                                         *v:exception* *exception-variable*
1314 v:exception     最も直近に捕捉され、まだ終了していない例外の値。
1315                 |v:throwpoint|と|throw-variables|を参照。
1316                 例: >
1317         :try
1318         :  throw "oops"
1319         :catch /.*/
1320         :  echo "caught" v:exception
1321         :endtry
1322 <               出力: "caught oops".
1323
1324                                         *v:fcs_reason* *fcs_reason-variable*
1325 v:fcs_reason    |FileChangedShell|イベントが発生した理由。オートコマンドの中で
1326                 何をすべきかやv:fcs_choiceに何を代入すべきかを決めるために使う。
1327                 値は次のどれかとなる:
1328                         deleted         もはやファイルが存在しない
1329                         conflict        ファイルの内容、モード、タイムスタンプ
1330                                         が変化しており、バッファが変更されてい
1331                                         る状態。
1332                         changed         ファイルの内容が変化している
1333                         mode            ファイルのモードが変化している
1334                         time            タイムスタンプだけが変化している
1335
1336                                         *v:fcs_choice* *fcs_choice-variable*
1337 v:fcs_choice    |FileChangedShell|イベントが発生した後に何をすべきかを表す。
1338                 オートコマンドの中で、そのバッファに対して何をすべきかを指示す
1339                 るために使う。
1340                         reload          バッファを読み直す(バッファが削除され
1341                                         ている場合には効果がない)。
1342                         ask             何をすべきかをユーザに問い合わせる。こ
1343                                         れはこのオートコマンドがない場合と同じ
1344                                         である。ただしタイムスタンプだけが変化
1345                                         しているときは何もしない。
1346                         <empty>         何もしない。オートコマンドの中だけで必
1347                                         要なことは全て行ってしまっているという
1348                                         場合にこの値を代入する。
1349                 既定値は<empty>。これら意外の(無効な)値が代入されたときは空の
1350                 ときと同じ動作になり、警告メッセージは表示されない。
1351
1352                                         *v:fname_in* *fname_in-variable*
1353 v:fname_in      入力ファイルの名前。以下のオプションを評価している最中のみ
1354                 有効:
1355                         オプション   このファイル名の意味 ~
1356                         'charconvert'   変換するファイル
1357                         'diffexpr'      元のファイル
1358                         'patchexpr'     元のファイル
1359                         'printexpr'     印刷するファイル
1360                 また、オートコマンドイベント|SwapExists|が発生したときスワップ
1361                 ファイル名が代入される。
1362
1363                                         *v:fname_out* *fname_out-variable*
1364 v:fname_out     出力ファイルの名前。以下のオプションを評価している最中のみ
1365                 有効:
1366                         オプション   このファイル名の意味 ~
1367                         'charconvert'   変換した結果のファイル (*)
1368                         'diffexpr'      diffの出力
1369                         'patchexpr'     パッチを当てた結果のファイル
1370                 (*) 書き込みコマンド(":w file"など)を実行する際の変換では
1371                 v:fname_inと同じになる。読み込みコマンド(":e file"など)を実行
1372                 する際の変換では一時ファイル名になり、v:fname_inと異なる。
1373
1374                                         *v:fname_new* *fname_new-variable*
1375 v:fname_new     新しい方のファイル名。'diffexpr'を評価している最中のみ有効。
1376
1377                                         *v:fname_diff* *fname_diff-variable*
1378 v:fname_diff    diff(patch)ファイルの名前。'patchexpr'を評価している最中のみ有
1379                 効。
1380
1381                                         *v:folddashes* *folddashes-variable*
1382 v:folddashes    'foldtext'用。閉じた折り畳みのレベルを表すダッシュ。
1383                 サンドボックス|sandbox|の中では読出し専用。|fold-foldtext|
1384
1385                                         *v:foldlevel* *foldlevel-variable*
1386 v:foldlevel     'foldtext'用。閉じた折り畳みのレベル。
1387                 サンドボックス|sandbox|の中では読出し専用。|fold-foldtext|
1388
1389                                         *v:foldend* *foldend-variable*
1390 v:foldend       'foldtext'用。閉じた折り畳みの最後の行。
1391                 サンドボックス|sandbox|の中では読出し専用。|fold-foldtext|
1392
1393                                         *v:foldstart* *foldstart-variable*
1394 v:foldstart     'foldtext'用。閉じた折り畳みの最初の行。
1395                 サンドボックス|sandbox|の中では読出し専用。|fold-foldtext|
1396
1397                                         *v:insertmode* *insertmode-variable*
1398 v:insertmode    オートコマンドイベント|InsertEnter|と|InsertChange|用。
1399                 値は次のどれか:
1400                         i       インサートモード
1401                         r       置換モード
1402                         v       ビジュアル置換モード
1403
1404                                                 *v:key* *key-variable*
1405 v:key           辞書|Dictionary|の現在の要素のキー。|map()|と|filter()|で使わ
1406                 れる式を評価している最中のみ有効。
1407                 読出し専用。
1408
1409                                                 *v:lang* *lang-variable*
1410 v:lang          メッセージに関する実行環境の現在のロケール設定。これを使えば
1411                 Vimスクリプト内で現在のロケール設定に対応できるようになる。
1412                 技術的な詳細: LC_MESSAGESに等しい。この値はシステムに依存する。
1413                 この変数を設定するには|:language|コマンドを使うこと。直接設定
1414                 することはできない。
1415                 文字エンコーディングに使うのと違う言語でメッセージを表示させた
1416                 い場合は|v:ctype|と異なる値でもよい。|multi-lang|を参照。
1417
1418                                                 *v:lc_time* *lc_time-variable*
1419 v:lc_time       時刻のメッセージに関する実行環境の現在のロケール設定。これを使
1420                 えばVimスクリプト内で現在のロケール設定に対応できるようになる。
1421                 技術的な詳細: LC_TIMEに等しい。この値はシステムに依存する。こ
1422                 の変数を設定するには|:language|コマンドを使うこと。直接設定す
1423                 ることはできない。
1424
1425                                                 *v:lnum* *lnum-variable*
1426 v:lnum          'foldexpr'と'indentexpr'に使うための行番号。また'guitablabel'
1427                 と'guitabtooltip'の文脈ではタブページ番号になる。これらの式のど
1428                 れかを評価しているときのみ有効。サンドボックス|sandbox|の中で
1429                 は読出し専用。
1430
1431                                         *v:mouse_win* *mouse_win-variable*
1432 v:mouse_win     |getchar()|でマウスクリックイベントを取得したとき、この変数に
1433                 ウィンドウ番号が代入されている。|winnr()|と同じく番号は1から始
1434                 まる。マウスがクリックされなかったときは0となる。
1435
1436                                         *v:mouse_lnum* *mouse_lnum-variable*
1437 v:mouse_lnum    |getchar()|でマウスクリックイベントを取得したとき、この変数に
1438                 行番号が代入されている。物理行ではなく論理行。マウスがクリック
1439                 されていないときは0となる。
1440
1441                                         *v:mouse_col* *mouse_col-variable*
1442 v:mouse_col     |getchar()|でマウスクリックイベントを取得したとき、この変数に
1443                 桁番号が代入されている。|virtcol()|と同じく画面上の桁番号。マ
1444                 ウスがクリックされていないときは0となる。
1445
1446                                         *v:oldfiles* *oldfiles-variable*
1447 v:oldfiles      起動時に |viminfo| から読み込まれたファイルの名前のリスト。
1448                 これらはマークを記憶しているファイルである。リストの長さの上限
1449                 はオプション 'viminfo' の引数 ' によって決まる(既定では 100)。
1450                 |:oldfiles| と |c_#<| を参照。
1451                 このリストは変更可能であるが、後で |viminfo| ファイルに書き込ま
1452                 れるものには影響しない。文字列以外の値を使うと問題を引き起こす
1453                 だろう。
1454                 {+viminfo 機能つきでコンパイルされたときのみ有効}
1455
1456                                         *v:operator* *operator-variable*
1457 v:operator      ノーマルモードにおいて最後に実行したオペレータコマンド。基本的に
1458                 1文字である。例外は <g> や <z> で始まるコマンドで、その場合は2文
1459                 字になる。|v:prevcount| と |v:register| と組み合わせて使うとよ
1460                 い。オペレータ待機モードをキャンセルして、それからオペレータを
1461                 使いたいときに便利である。例: >
1462                         :omap O <Esc>:call MyMotion(v:operator)<CR>
1463 <               この値は他のオペレータが入力されるまでセットされてい
1464                 る。よって空になると期待してはいけない。
1465                 |:delete|, |:yank| などの Ex コマンドに対しては v:operator は
1466                 セットされない。
1467                 読出し専用。
1468
1469                                         *v:prevcount* *prevcount-variable*
1470 v:prevcount     最後のノーマルモードコマンドに与えられたカウントの値。前のコマ
1471                 ンドのv:countの値である。ビジュアルモードやオペレータ待機モー
1472                 ドをキャンセルし、その後にカウントを使う場合に便利である。
1473                 例: >
1474                         :vmap % <Esc>:call MyFilter(v:prevcount)<CR>
1475 <               読出し専用。
1476
1477                                         *v:profiling* *profiling-variable*
1478 v:profiling     通常時は0。":profile start"を実行すると1が代入される。
1479                 |profiling|を参照。
1480
1481                                         *v:progname* *progname-variable*
1482 v:progname      Vimを起動したときのプログラム名(パスは除かれる)。"view"、
1483                 "evim"などの名前やシンボリックリンクなどで起動した場合に特別な
1484                 初期化を行うのに便利。
1485                 読出し専用。
1486
1487                                         *v:register* *register-variable*
1488 v:register      最後のノーマルモードコマンドに指定されたレジスタの名前。レジス
1489                 タが指定されなかったときは空。|getreg()| |setreg()|
1490
1491                                         *v:scrollstart* *scrollstart-variable*
1492 v:scrollstart   画面のスクロールの原因となったスクリプトや関数を説明する
1493                 文字列。空であるときのみ代入される。よってこの変数には最初の原
1494                 因だけが記録されている。原因がキーボードから入力されたコマンド
1495                 の場合は"Unknown"が代入される。
1496                 スクリプトを実行したとき現れたhit-enterプロンプトの原因を探る
1497                 ために便利。
1498
1499                                         *v:servername* *servername-variable*
1500 v:servername    |x11-clientserver|に登録されている名前。
1501                 読出し専用。
1502
1503
1504 v:searchforward                 *v:searchforward* *searchforward-variable*
1505                 検索方向: 前方検索の後なら1、後方検索の後なら0。|quote/| で示す
1506                 方法によって最終検索パターンを直接セットしたときは0(前方検索)
1507                 にセットされる。関数から戻るとき、この値は呼び出し前の値に復元
1508                 される。
1509                 |function-search-undo|。
1510                 読み書き両用。
1511
1512                                         *v:shell_error* *shell_error-variable*
1513 v:shell_error   最後に実行したシェルコマンドの結果。シェルコマンドの実行時にな
1514                 にかエラーがあったならば、非零の値を取る。問題がなければ零にな
1515                 る。これはシェルがエラーコードをVimに通知する時のみ働く。コマ
1516                 ンドが実行されなかった時には、値として-1が良く使われる。読出し
1517                 専用。
1518                 例: >
1519         :!mv foo bar
1520         :if v:shell_error
1521         :  echo 'could not rename "foo" to "bar"!'
1522         :endif
1523 <               また"shell_error"は、以前の版のVimとの互換性の為に動作する。
1524
1525                                         *v:statusmsg* *statusmsg-variable*
1526 v:statusmsg     最後に表示されたステータスメッセージ。この変数は代入すること
1527                 が許されている。
1528
1529                                         *v:swapname* *swapname-variable*
1530 v:swapname      オートコマンド|SwapExists|を実行している最中のみ有効。見つかっ
1531                 たスワップファイルの名前。読出し専用。
1532
1533                                         *v:swapchoice* *swapchoice-variable*
1534 v:swapchoice    イベント|SwapExists|により実行されたオートコマンドが、見つかっ
1535                 たスワップファイルをどう処理するかをこの変数に代入する。
1536                         'o'     読込専用で開く
1537                         'e'     とにかく編集する
1538                         'r'     復活させる
1539                         'd'     スワップファイルを削除する
1540                         'q'     終了する
1541                         'a'     中止する
1542                 この変数の値は1文字の文字列でなければならない。値が空のときは
1543                 オートコマンドSwapExistsが存在しないときと同じようにユーザに問
1544                 い合わせる。既定値は空。
1545
1546                                         *v:swapcommand* *swapcommand-variable*
1547 v:swapcommand   ファイルを開いた後に実行するノーマルモードコマンド。オートコマ
1548                 ンド|SwapExists|で、他のVimインスタンスにファイルを開かせ、指
1549                 定位置までジャンプするために使うことができる。例えば、あるタグ
1550                 へジャンプするには、この変数に":tag tagname\r"という値を代入す
1551                 る。":edit +cmd file"を実行させるには":cmd\r"を代入する。
1552
1553                                 *v:termresponse* *termresponse-variable*
1554 v:termresponse  termcapのエントリ|t_RV|で端末から返されるエスケープシーケン
1555                 ス。ESC [またはCSIで始まり、途中数字と';'と'.'だけから構成され
1556                 'c'で終わるエスケープシーケンスを受け取ったとき代入される。
1557                 このオプションがセットされるとオートコマンドイベント
1558                 TermResponseが発生し、端末からの応答に反応することができる。
1559                 新しいxtermからの応答は次の形式である:
1560                  "<Esc>[ Pp ; Pv ; Pc c"。ここでPpは端末のタイプ: 0ならvt100、
1561                  1ならvt220。Pvはパッチレベル(パッチ95で導入されたため常
1562                  に95以上)。Pcは常に0。
1563                 {Vi mが|+termresponse|機能付きでコンパイルされたときのみ有効}
1564
1565                                 *v:this_session* *this_session-variable*
1566 v:this_session  最後にロードされたか、セーブされたセッションファイルの完全な
1567                 ファイル名。|:mksession|を参照。この変数は代入することが許さ
1568                 れている。それ以前にセーブされたセッションがなければ、この変数
1569                 は空となる。
1570                 また"this_session"は、以前の版のVimとの互換性の為に動作する。
1571
1572                                         *v:throwpoint* *throwpoint-variable*
1573 v:throwpoint    最も直近に捕捉されてまだ終了していない例外が発生した位置。キー
1574                 ボードから入力されたコマンドは記録されていない。|v:exception|
1575                 と|throw-variables|も参照。
1576                 例: >
1577         :try
1578         :  throw "oops"
1579         :catch /.*/
1580         :  echo "Exception from" v:throwpoint
1581         :endtry
1582 <               出力: "Exception from test.vim, line 2"
1583
1584                                                 *v:val* *val-variable*
1585 v:val           辞書|Dictionary|の現在の要素の値。|map()|と|filter()|で使わ
1586                 れる式を評価している最中のみ有効。
1587                 読出し専用。
1588
1589                                 *v:version* *version-variable*
1590 v:version       Vimのバージョン番号。メジャーバージョン番号は100倍され、マイ
1591                 ナーバージョン番号と足されている。Version 5.0は500。Version
1592                 5.1 (5.01)は501となる。読出し専用。また"version"は、以前の版の
1593                 Vimとの互換性の為に動作する。
1594                 特定のパッチが摘要されているかを調べるには|has()|を使う。例: >
1595                         if has("patch123")
1596 <               5.0と5.1には両方ともパッチ123が存在しているが、バージョンが違
1597                 えば番号は同じでもパッチの内容は全く異なっている。
1598
1599                                         *v:warningmsg* *warningmsg-variable*
1600 v:warningmsg    最後に表示された警告メッセージ。この変数は代入することが許され
1601                 ている。
1602
1603 ==============================================================================
1604 4. 組み込み関数                                               *functions*
1605
1606 (関数名の上でCTRL-]を使うことで、詳細な説明へ飛ぶことができる)
1607
1608 使用法                             結果      説明              ~
1609
1610 abs( {expr})                    浮動小数点数または数値     {expr}の絶対値
1611 add( {list}, {item})            リスト     {item}をリスト{list}に追加する
1612 append( {lnum}, {string})       数値      {string}を{lnum}行目に付け加える
1613 append( {lnum}, {list})         数値      行{list}を{lnum}行目に付け加える
1614 argc()                          数値      引数内のファイルの数
1615 argv( {nr})                     文字列     引数の第{nr}番目
1616 argv( )                         リスト     引数リスト
1617 atan( {expr})                   浮動小数点数  {expr}のアークタンジェント
1618 browse( {save}, {title}, {initdir}, {default})
1619                                 文字列     ファイル選択ダイアログを表示
1620 browsedir( {title}, {initdir})  文字列     ディレクトリ選択ダイアログを表示
1621 bufexists( {expr})              数値      バッファ{expr}が存在すればTRUE
1622 buflisted( {expr})              数値      バッファ{expr}がリストにあるならTRUE
1623 bufloaded( {expr})              数値      バッファ{expr}がロード済みならTRUE
1624 bufname( {expr})                文字列     バッファ{expr}の名前
1625 bufnr( {expr})                  数値      バッファ{expr}の番号
1626 bufwinnr( {nr})                 数値      バッファ{nr}のウィンドウ番号
1627 byte2line( {byte})              数値      {byte}番目のバイトの行番号
1628 byteidx( {expr}, {nr})          数値      {expr}の{nr}文字目のバイトインデックス
1629 call( {func}, {arglist} [, {dict}])
1630                                 任意      引数{arglist}をつけて{func}を呼ぶ
1631 ceil( {expr})                   浮動小数点数  {expr} を切り上げる
1632 changenr()                      数値      現在の変更番号
1633 char2nr( {expr})                数値      {expr}の先頭文字のASCIIコード
1634 cindent( {lnum})                数値      {lnum}行目のCインデント量
1635 clearmatches()                  なし      全マッチをクリアする
1636 col( {expr})                    数値      カーソルかマークのカラム番号nr
1637 complete( {startcol}, {matches}) なし     インサートモード補完を設定する
1638 complete({startcol}, {matches}) 文字列  インサートモード補完の結果を設定する
1639 complete_add( {expr})           数値      補完候補を追加する
1640 complete_check()                数値      補完中に押されたキーをチェックする
1641 confirm( {msg}, {choices} [, {default} [, {type}]])
1642                                 数値      ユーザへの選択肢と番号
1643 copy( {expr})                   任意      {expr}の浅いコピーを作る
1644 cos( {expr})                    浮動小数点数  {expr} の余弦(コサイン)
1645 count( {list}, {expr} [, {start} [, {ic}]])
1646                                 数値       {list}中に{expr}が何個現れるか数える
1647 cscope_connection( [{num} , {dbpath} [, {prepend}]])
1648                                 数値      cscope接続の存在を判定する
1649 cursor( {lnum}, {col} [, {coladd}])
1650                                 数値      カーソルを{lnum}, {col}, {coladd}へ移動
1651 cursor( {list})                 数値      カーソルを{list}の位置へ移動
1652 deepcopy( {expr})               任意      {expr}の完全なコピーを作る
1653 delete( {fname})                数値      ファイル{fname}を消す
1654 did_filetype()                  数値      FileTypeのautocommandが実行されたか?
1655 diff_filler( {lnum})            数値      diffモードで{lnum}に挿入された行
1656 diff_hlID( {lnum}, {col})       数値      diffモードで{lnum}/{col}位置の強調
1657 empty( {expr})                  数値      {expr}が空ならTRUE
1658 escape( {string}, {chars})      文字列     {string}内の{chars}を'\'でエスケープ
1659 eval( {string})                 任意      {string}を評価し、値を得る
1660 eventhandler( )                 数値      イベントハンドラの内側ならTRUE
1661 executable( {expr})             数値      実行可能な{expr}が存在するなら1
1662 exists( {var})                  数値      変数{var}が存在したらTRUE
1663 extend( {expr1}, {expr2} [, {expr3}])
1664                                 リスト/辞書 {expr1}に{expr2}の要素を挿入
1665 expand( {expr} [, {flag}])      文字列     {expr}内の特別なキーワードを展開
1666 feedkeys( {string} [, {mode}])  数値      先行入力バッファにキーシーケンスを追加
1667 filereadable( {file})           数値      {file}が読みこみ可能ならTRUE
1668 filewritable( {file})           Number  {file}が書き込み可能ならTRUE
1669 filter( {expr}, {string})       リスト/辞書  {string}が0となる要素を{expr}から
1670                                         とり除く
1671 finddir( {name}[, {path}[, {count}]])
1672                                 文字列     {path}からディレクトリ{name}を探す
1673 findfile( {name}[, {path}[, {count}]])
1674                                 文字列     {path}からファイル{name}を探す
1675 float2nr( {expr})               数値      浮動小数点数 {expr} を数値に変換する
1676 floor( {expr})                  浮動小数点数  {expr} を切り捨てる
1677 fnameescape( {fname})           文字列     {fname} 内のの特殊文字をエスケープする
1678 fnamemodify( {fname}, {mods})   文字列     ファイル名を変更
1679 foldclosed( {lnum})             数値      {lnum}の折り畳みの最初の行(閉じている
1680                                         なら)
1681 foldclosedend( {lnum})          数値      {lnum}の折り畳みの最後の行(閉じている
1682                                         なら)
1683 foldlevel( {lnum})              数値      {lnum}の折り畳みレベル
1684 foldtext( )                     文字列     閉じた折り畳みに表示されている行
1685 foldtextresult( {lnum})         文字列     {lnum}で閉じている折り畳みのテキスト
1686 foreground( )                   数値      Vimウィンドウを前面に移動する
1687 function( {name})               Funcref 関数{name}への参照を取得
1688 garbagecollect( [at_exit])      なし      メモリを解放する。循環参照を断ち切る
1689 get( {list}, {idx} [, {def}])   任意      {list}や{def}から要素{idx}を取得
1690 get( {dict}, {key} [, {def}])   任意      {dict}や{def}から要素{key}を取得
1691 getbufline( {expr}, {lnum} [, {end}])
1692                                 リスト     バッファ{expr}の{lnum}から{end}行目
1693 getbufvar( {expr}, {varname})   任意      バッファ{expr}の変数 {varname}
1694 getcmdline()                    文字列     現在のコマンドラインを取得
1695 getcmdpos()                     数値      コマンドラインのカーソル位置を取得
1696 getcmdtype()                    文字列     現在のコマンドラインの種類を取得
1697 getcwd()                        文字列     現在の作業ディレクトリ
1698 getfperm( {fname})              文字列     ファイル{fname}の許可属性を取得
1699 getfsize( {fname})              数値      ファイル{fname}のバイト数を取得
1700 getfontname( [{name}])          文字列     使用しているフォントの名前
1701 getftime( {fname})              数値      ファイルの最終更新時間
1702 getftype( {fname})              文字列     ファイル{fname}の種類の説明
1703 getline( {lnum})                文字列     現在のバッファから行の内容を取得
1704 getline( {lnum}, {end})         リスト     カレントバッファの{lnum}から{end}行目
1705 getloclist( {nr})               リスト     ロケーションリストの要素のリスト
1706 getmatches()                    リスト     現在のマッチのリスト
1707 getpid()                        数値      Vim のプロセス ID
1708 getpos( {expr})                 リスト     カーソル・マークなどの位置を取得
1709 getqflist()                     リスト     quickfixリストの要素のリスト
1710 getreg( [{regname} [, 1]])      文字列     レジスタの中身を取得
1711 getregtype( [{regname}])        文字列     レジスタの種類を取得
1712 gettabwinvar( {tabnr}, {winnr}, {name})
1713                                 任意      タブページ{tabnr}の{winnr}の{name}
1714 getwinposx()                    数値      GUI vim windowのX座標
1715 getwinposy()                    数値      GUI vim windowのY座標
1716 getwinvar( {nr}, {varname})     文字列     ウィンドウ{nr}の変数{varname}
1717 glob( {expr} [, {flag}])        文字列     {expr}内のfile wildcardを展開
1718 globpath( {path}, {expr} [, {flag}])
1719                                 文字列     {path}の全ディレクトリに対し
1720                                         glob({expr})を行う
1721 has( {feature})                 数値      機能{feature}がサポートならばTRUE
1722 has_key( {dict}, {key})         数値      {dict}が要素{key}を持つならTRUE
1723 haslocaldir()                   数値      現在のウィンドウで|:lcd|が実行された
1724                                         ならTRUE
1725 hasmapto( {what} [, {mode} [, {abbr}]])
1726                                 数値      {what}へのマッピングが存在するならTRUE
1727 histadd( {history},{item})      文字列     ヒストリに追加
1728 histdel( {history} [, {item}])  文字列     ヒストリからitemを削除
1729 histget( {history} [, {index}]) 文字列     ヒストリから{index}アイテムを取得
1730 histnr( {history})              数値      ヒストリの数
1731 hlexists( {name})               数値      highligth group {name}が存在したらTRUE
1732 hlID( {name})                   数値      highlight group {name}のID
1733 hostname()                      文字列     vimが動作しているマシンの名前
1734 iconv( {expr}, {from}, {to})    文字列     {expr}のエンコーディングを変換する
1735 indent( {lnum})                 文字列     行{lnum}のインデントを取得
1736 index( {list}, {expr} [, {start} [, {ic}]])
1737                                 数値      {list}中に{expr}が現れる位置
1738 input( {prompt} [, {text} [, {completion}]])
1739                                 文字列     ユーザからの入力を取得
1740 inputdialog( {p} [, {t} [, {c}]]) 文字列  input()と同様。GUIのダイアログを使用
1741 inputlist( {textlist})          数値      ユーザに選択肢から選ばせる
1742 inputrestore()                  数値      先行入力を復元する
1743 inputsave()                     数値      先行入力を保存し、クリアする
1744 inputsecret( {prompt} [, {text}]) 文字列  input()だがテキストを隠す
1745 insert( {list}, {item} [, {idx}]) リスト  {list}に要素{item}を挿入 [{idx}の前]
1746 isdirectory( {directory})       数値      {directory}がディレクトリならばTRUE
1747 islocked( {expr})               数値      {expr}がロックされているならTRUE
1748 items( {dict})                  リスト     {dict}のキーと値のペアを取得
1749 join( {list} [, {sep}])         文字列     {list}の要素を連結して文字列にする
1750 keys( {dict})                   リスト     {dict}のキーを取得
1751 len( {expr})                    数値      {expr}の長さを取得
1752 libcall( {lib}, {func}, {arg}   文字列     ライブラリ{lib}の関数{func}をコール
1753 libcallnr( {lib}, {func}, {arg})  数値  上と同じ。ただし数値を返す
1754 line( {expr})                   数値      行番号の取得
1755 line2byte( {lnum})              数値      行{lnum}のバイトカウント
1756 lispindent( {lnum})             数値      {lnum}行目のLispインデント量を取得
1757 localtime()                     数値      現在時刻
1758 log10( {expr})                  浮動小数点数  浮動小数点数 {expr} の 10 を底
1759                                         とする対数
1760 map( {expr}, {string})          リスト/辞書  {expr}の各要素を{expr}に変える
1761 matchadd( {group}, {pattern}[, {priority}[, {id}]])
1762                                 数値      {pattern} を {group} で強調表示する
1763 maparg( {name}[, {mode} [, {abbr}]])
1764                                 文字列     モード{mode}でのマッピング{name}の値
1765 mapcheck( {name}[, {mode} [, {abbr}]])
1766                                 文字列     {name}にマッチするマッピングを確認
1767 match( {expr}, {pat}[, {start}[, {count}]])
1768                                 数値      {expr}内で{pat}がマッチする位置
1769 matcharg( {nr})                 リスト     |:match|の引数
1770 matchdelete( {id})              数値      {id} で指定されるマッチを削除する
1771 matchend( {expr}, {pat}[, {start}[, {count}]])
1772                                 数値      {expr}内で{pat}が終了する位置
1773 matchlist( {expr}, {pat}[, {start}[, {count}]])
1774                                 リスト     {expr}内の{pat}のマッチと部分マッチ
1775 matchstr( {expr}, {pat}[, {start}[, {count}]])
1776                                 文字列     {expr}内の{count}'番目の{pat}のマッチ
1777 max( {list})                    数値      {list}内の要素の最大値
1778 min( {list})                    数値      {list}内の要素の最小値
1779 mkdir( {name} [, {path} [, {prot}]])
1780                                 数値      ディレクトリ{name}を作成
1781 mode( [expr])                   文字列     現在の編集モード
1782 nextnonblank( {lnum})           数値      {lnum}行目以降で空行でない行の行番号
1783 nr2char( {expr})                文字列     ASCIIコード{expr}で示されるキャラクタ
1784 pathshorten( {expr})            文字列     path内の短縮したディレクトリ名
1785 pow( {x}, {y})                  浮動小数点数  {x} の {y} 乗
1786 prevnonblank( {lnum})           数値      {lnum}行目以前の空行でない行の行番号
1787 printf( {fmt}, {expr1}...)      文字列  文字列を組み立てる
1788 pumvisible()                    数値    ポップアップメニューが表示されているか
1789 range( {expr} [, {max} [, {stride}]])
1790                                 リスト     {expr}から{max}までの要素のリスト
1791 readfile( {fname} [, {binary} [, {max}]])
1792                                 リスト     ファイル{fname}から行のリストを取得
1793 reltime( [{start} [, {end}]])   リスト     時刻の値を取得
1794 reltimestr( {time})             文字列     時刻の値を文字列に変換
1795 remote_expr( {server}, {string} [, {idvar}])
1796                                 文字列     式を送信する
1797 remote_foreground( {server})    数値      Vimサーバを前面に出す
1798 remote_peek( {serverid} [, {retvar}])
1799                                 数値      返信文字列を確認する
1800 remote_read( {serverid})        文字列     返信文字列を読み込む
1801 remote_send( {server}, {string} [, {idvar}])
1802                                 文字列     キーシーケンスを送信する
1803 remove( {list}, {idx} [, {end}])  任意    {list}から{idx}〜{end}の要素を削除
1804 remove( {dict}, {key})          任意      {dict}から要素{key}を削除
1805 rename({from}, {to})            数値      {file}から{to}へファイル名変更
1806 repeat( {expr}, {count})        文字列     {expr}を{count}回繰り返す
1807 resolve( {filename})            文字列     ショートカットが指す先のファイル名
1808 reverse( {list})                文字列     {list}をその場で反転させる
1809 round( {expr})                  浮動小数点数  {expr} を四捨五入する
1810 search( {pattern} [, {flags} [, {stopline} [, {timeout}]]])
1811                                 数値      {pattern} を検索する
1812 searchdecl( {name} [, {global} [, {thisblock}]])
1813                                 数値    変数の宣言を検索
1814 searchpair( {start}, {middle}, {end} [, {flags} [, {skip} [...]]])
1815                                 数値      開始/終端のペアの他方を検索
1816 searchpairpos( {start}, {middle}, {end} [, {flags} [, {skip} [...]]])
1817                                 リスト     開始/終端のペアの他方を検索
1818 searchpos( {pattern} [, {flags} [, {stopline} [, {timeout}]]])
1819                                 リスト     {pattern}を検索
1820 server2client( {clientid}, {string})
1821                                 数値      返信文字列を送信する
1822 serverlist()                    文字列     利用可能なサーバのリストを取得
1823 setbufvar( {expr}, {varname}, {val})    バッファ{expr}内の変数{varname}に{val}
1824                                         をセット
1825 setcmdpos( {pos})               数値      コマンドライン内のカーソル位置を設定
1826 setline( {lnum}, {line})        数値      行{lnum}に{line}(文字列)をセット
1827 setloclist( {nr}, {list}[, {action}])
1828                                 数値      {list}を使ってロケーションリストを変更
1829 setmatches( {list})             数値      マッチのリストを復元する
1830 setpos( {expr}, {list})         なし      {expr}の位置を{list}にする
1831 setqflist( {list}[, {action}])  数値      {list}を使ってQuickFixリストを変更
1832 setreg( {n}, {v}[, {opt}])      数値      レジスタの値とタイプを設定
1833 settabwinvar( {tabnr}, {winnr}, {varname}, {val})  タブページ{tabnr}内のウィン
1834                                         ドウ{nr}の変数{varname}に{val}をセット
1835                                         {winnr} in tab page {tabnr} to {val}
1836 setwinvar( {nr}, {varname}, {val})      ウィンドウ{nr}の変数{varname}に{val}を
1837                                         セット
1838 shellescape( {string} [, {special}])
1839                                 文字列     {string}をシェルコマンド引数として使う
1840                                         ためにエスケープする。
1841 simplify( {filename})           文字列     ファイル名を可能なかぎり簡略化する
1842 sin( {expr})                    浮動小数点数  {expr} の正弦(サイン)
1843 sort( {list} [, {func}])        リスト     比較に{func}を使って{list}をソートする
1844 soundfold( {word})              文字列     {word}のsound-fold
1845 spellbadword()                  文字列     カーソル位置のスペルミスした単語
1846 spellsuggest( {word} [, {max} [, {capital}]])
1847                                 リスト     スペリング補完
1848 split( {expr} [, {pat} [, {keepempty}]])
1849                                 リスト     {expr}を{pat}で区切ってリストを作る
1850 sqrt( {expr}                    浮動小数点数  {expr} の平方根
1851 str2float( {expr})              浮動小数点数  文字列を浮動小数点数に変換する
1852 str2nr( {expr} [, {base}])      数値      文字列を数値に変換する
1853 strftime( {format}[, {time}])   文字列     指定されたフォーマットでの時刻
1854 stridx( {haystack}, {needle}[, {start}])
1855                                 数値      {haystack}内の{needle}のインデックス
1856 string( {expr})                 文字列     {expr}の値の文字列表現
1857 strlen( {expr})                 数値      文字列{expr}の長さ
1858 strpart( {src}, {start}[, {len}])
1859                                 文字列     {src}内{start}から長さ{len}の部分
1860 strridx( {haystack}, {needle} [, {start}])
1861                                 数値      {haystack}内の最後の{needle}のインデッ
1862                                         クス
1863 strtrans( {expr})               文字列     文字列を表示可能に変更
1864 submatch( {nr})                 文字列     ":substitute"における特定のマッチ
1865 substitute( {expr}, {pat}, {sub}, {flags})
1866                                 文字列     {expr}の{pat}を{sub}に置換え
1867 synID( {line}, {col}, {trans})  数値      {line}と{col}のsyntax IDを取得
1868 synIDattr( {synID}, {what} [, {mode}])
1869                                 文字列     syntax ID{synID}の属性{what}を取得
1870 synIDtrans( {synID})            数値      {synID}の翻訳されたsyntax ID
1871 synstack( {lnum}, {col})        リスト     {lnum}行{col}列目における構文IDの
1872                                         スタック
1873 system( {expr} [, {input}])     文字列     シェルコマンド{expr}の出力結果
1874 tabpagebuflist( [{arg}])        リスト     タブページ内のバッファ番号のリスト
1875 tabpagenr( [{arg}])             数値      現在または最後のタブページの番号
1876 tabpagewinnr( {tabarg}[, {arg}])
1877                                 数値      タブページ内の現在のウィンドウの番号
1878 taglist( {expr})                リスト     {expr}にマッチするタグのリスト
1879 tagfiles()                      リスト  使用しているタグファイルのリスと
1880 tempname()                      文字列     テンポラリファイルの名前
1881 tolower( {expr})                文字列     文字列{expr}を小文字にする
1882 toupper( {expr})                文字列     文字列{expr}を大文字にする
1883 tr( {src}, {fromstr}, {tostr})  文字列     {src}中に現れる文字{fromstr}を{tostr}
1884                                         に変換する。
1885 trunc( {expr}                   浮動小数点数  浮動小数点数 {expr} を切り詰め
1886                                         る
1887 type( {name})                   数値      変数{name}の型
1888 values( {dict})                 リスト     {dict}の値のリスト
1889 virtcol( {expr})                数値      カーソルのスクリーンカラム位置
1890 visualmode( [expr])             文字列     最後に使われたVisualモード
1891 winbufnr( {nr})                 数値      ウィンドウ{nr}のバッファ番号
1892 wincol()                        数値      カーソル位置のウィンドウ桁
1893 winheight( {nr})                数値      ウィンドウ{nr}の高さ
1894 winline()                       数値      カーソル位置のウィンドウ行
1895 winnr()                         数値      現在のウィンドウの番号
1896 winrestcmd()                    文字列     ウィンドウサイズを復元するコマンド
1897 winrestview( {dict})            なし      現在のウィンドウのビューを復元
1898 winsaveview()                   辞書      現在のウィンドウのビューを保存
1899 winwidth( {nr})                 数値      ウィンドウ{nr}の幅を取得
1900 writefile( {list}, {fname} [, {binary}])
1901                                 数値      行のリストをファイル{fname}に書き込む
1902
1903
1904 abs({expr})                                                     *abs()*
1905                 {expr} の絶対値を返す。{expr} の値が浮動小数点数である場合は浮
1906                 動小数点数を返す。{expr} が|Number|に変換可能な場合は数値が戻
1907                 り値になる。それ以外の場合はエラーメッセージを表示し、-1
1908                 を返す。
1909                 例: >
1910                         echo abs(1.456)
1911 <                       1.456  >
1912                         echo abs(-5.456)
1913 <                       5.456  >
1914                         echo abs(-4)
1915 <                       4
1916                 {|+float| 機能を有効にしてコンパイルしたときのみ有効}}
1917
1918 add({list}, {expr})                                     *add()*
1919                 リスト|List|{list}の末尾に要素{expr}を追加する。結果のリストを
1920                 返す。例: >
1921                         :let alist = add([1, 2, 3], item)
1922                         :call add(mylist, "woodstock")
1923 <               Note {expr}がリストのときは、1個の要素として追加される。リスト
1924                 を連結するには|extend()|を使う。
1925                 他の位置に要素を追加するには|insert()|を使う。
1926
1927
1928 append({lnum}, {expr})                                  *append()*
1929                 {expr}がリスト|List|のときは、各要素をカレントバッファの{lnum}
1930                 行目以降にテキストとして追加する。
1931                 リストでないときは、{expr}をテキストとしてカレントバッファの{lnum}
1932                 行目以降にテキストとして追加する。
1933                 {lnum}は0でもよく、その場合は1行目の前に行を挿入する。
1934                 失敗した場合は0を返す({lnum}が不正な範囲であるか、メモリ不足)。
1935                 成功なら0を返す。例: >
1936                         :let failed = append(line('$'), "# THE END")
1937                         :let failed = append(0, ["Chapter 1", "the beginning"])
1938 <
1939                                                         *argc()*
1940 argc()          カレントウィンドウの引数リスト内の、ファイルの数を返す。
1941                 |arglist|を参照。
1942
1943                                                         *argidx()*
1944 argidx()        引数リスト内の現在のインデックスを返す。最初のファイルは0とな
1945                 る。argc() - 1が最後のファイルとなる。|arglist|を参照。
1946
1947                                                         *argv()*
1948 argv([{nr}])    結果は引数リスト内の、{nr}番目のファイル。|arglist|を参照。
1949                 "argv(0)"は一番最初のファイルを示す。例: >
1950         :let i = 0
1951         :while i < argc()
1952         :  let f = escape(fnameescape(argv(i)), '.')
1953         :  exe 'amenu Arg.' . f . ' :e ' . f . '<CR>'
1954         :  let i = i + 1
1955         :endwhile
1956 <               引数{nr}が指定されなかった場合は、引数リスト|arglist|全体を
1957                 返す。
1958
1959 atan({expr})                                            *atan()*
1960                 {expr} の逆正接(アークタンジェント)の主値を浮動小数点数
1961                 |Float| で返す。主値はラジアンで[-pi/2, +pi/2]の範囲内にある。
1962                 {expr} は |Float| か |Number| に評価されなければならない。
1963                 例: >
1964                         :echo atan(100)
1965 <                       1.560797 >
1966                         :echo atan(-4.01)
1967 <                       -1.326405
1968                 {|+float| 機能つきでコンパイルされたときのみ有効}
1969
1970                                                         *browse()*
1971 browse({save}, {title}, {initdir}, {default})
1972                 ファイル選択ダイアログを起動。"has("browser")"が非零を返すとき
1973                 (幾つかのGUIバージョンに限定)だけ利用可能。
1974                 入力フィールドの意味は:
1975                     {save}      非零ならば書込み用ファイルの選択
1976                     {title}     ダイアログのタイトル
1977                     {initdir}   ダイアログの始まるディレクトリ
1978                     {default}   ファイル名の省略値
1979                 ダイアログがキャンセルされるか、何かエラーがあるか、もしくはブ
1980                 ラウジングが不可能ならば、空文字列が戻ってくる。
1981
1982                                                         *browsedir()*
1983 browsedir({title}, {initdir})
1984                 ディレクトリ選択ダイアログを起動。"has("browse")"が非零を返す
1985                 とき(幾つかのGUIバージョンに限定)だけ利用可能。
1986                 ディレクトリ選択ダイアログがないシステムにおいてはファイル選択
1987                 ダイアログが使われる。その場合は、指定したいディレクトリの中の
1988                 ファイルを選択すること。
1989                 入力フィールドの意味は:
1990                     {title}     ダイアログのタイトル
1991                     {initdir}   ダイアログの始まるディレクトリ
1992                 ダイアログがキャンセルされるか、何かエラーがあるか、もしくはブ
1993                 ラウジングが不可能ならば、空文字列が戻ってくる。
1994
1995                                                         *bufexists()*
1996 bufexists({expr})
1997                 結果は数値で、{expr}と呼ばれるバッファが存在すれば非零となる。
1998                 {expr}が数値の場合、バッファ番号とみなされる。
1999                 {expr}が文字列の場合、バッファ名に正確にマッチしなければな
2000                 らない。名前として以下のものが許される:
2001                 - カレントディレクトリからの相対パス。
2002                 - フルパス。
2003                 - 'buftype'が"nofile"であるバッファの名前
2004                 - URL名。
2005                 バッファリストにないバッファも検索される。
2006                 Note |:buffers|の出力で、ヘルプファイルは短い名前でリストされ
2007                 ているが、bufexists()は長い名前でないと見つけることができない。
2008                 ある名前を bufexists() に与えて非零になったとしても、その名前
2009                 をコマンド |:buffer| に与える際には |expand()| を使って展開し
2010                 なければならない場合がある。特に MS-Windows の "c:\DOCUME~1"
2011                 という 8.3 名形式において。
2012                 代替ファイル名が存在するかを判定するには"bufexists(0)"を使う。
2013                                                         *buffer_exists()*
2014                 以前の名前: buffer_exists().
2015
2016                                                         *bufloaded()*
2017 bufloaded({expr})
2018                 戻り値は数値で、{expr}と呼ばれるバッファが存在しロード済み(
2019                 ウィンドウに表示されているか、隠されているかは問わない)ならば
2020                 結果は非零となる。引数{expr}は|bufexists()|と同じように扱われ
2021                 る。
2022
2023                                                         *bufname()*
2024 bufname({expr})
2025                 戻り値はバッファの名前。バッファ名はコマンド":ls"で表示される
2026                 ものと同様。
2027                 {expr}が数値ならば、その番号のバッファ名が返される。0は現在の
2028                 ウィンドウの代替バッファを意味する。{expr}が文字列ならば、バッ
2029                 ファ名に対してファイル名マッチング|file-pattern|を行なうパター
2030                 ンとなる。このマッチングは常に、'magic'をセットし'cpoptions'を
2031                 空にした状態で行なわれる。複数マッチしてしまった場合には空文字
2032                 列が返される。""や"%"は現在のバッファを意味し、"#"は代替バッファ
2033                 を意味する。
2034                 完全マッチのものが優先され、完全マッチがなければ、バッファ名の
2035                 先頭でのマッチ、末尾でのマッチ、中間でのマッチが探される。完全
2036                 マッチのみを探すには、パターン先頭に"^"を、末尾に"$"をつける。
2037                 まずバッファリストにあるバッファが探される。そこで1個だけマッ
2038                 チが見つかればそれを返す。次にバッファリストにないものが探され
2039                 る。
2040                 {expr}が文字列のときに、それをバッファ番号として使いたいなら
2041                 ば、0を足すことによって強制的に数値にすることができる: >
2042                         echo bufname("3" + 0)
2043 <               バッファが存在しないか名前を持っていない場合には、空文字列が返
2044                 される。 >
2045   bufname("#")                  alternate buffer name
2046   bufname(3)                    name of buffer 3
2047   bufname("%")                  name of current buffer
2048   bufname("file2")              name of buffer where "file2" matches.
2049 <                                                       *buffer_name()*
2050                 以前の名前: buffer_name().
2051
2052                                                         *bufnr()*
2053 bufnr({expr} [, {create}])
2054                 結果はバッファの番号。バッファ番号はコマンド":ls"で表示される
2055                 ものと同様。{expr}の使い方は前述のbufname()を参照。バッファが
2056                 存在しない場合-1が返される。ただし、{create}が与えられて0でな
2057                 いときは、バッファリストに載せない新しいバッファを作成しその番
2058                 号を返す。
2059                 bufnr("$")は最後のバッファを意味する: >
2060   :let last_buffer = bufnr("$")
2061 <               結果は存在しているバッファのうちで、もっとも大きなバッファ番号
2062                 となる。 Note そのバッファ番号より小さいバッファ番号を持つ(ハ
2063                 ズの)バッファが、必ずしも総て存在するとは限らない。なぜなら
2064                 ":bwipeout"がバッファを消すことができるからだ。バッファが存在
2065                 するかテストするにはbufexists()を使う。
2066                                                         *buffer_number()*
2067                 以前の名前: buffer_number().
2068                                                         *last_buffer_nr()*
2069                 bufnr("$")の以前の名前: last_buffer_nr().
2070
2071                                                         *bufwinnr()*
2072 bufwinnr({expr})
2073                 結果は数値で、バッファ{expr}に関連付けられた最初のウィンドウの
2074                 番号。{expr}の使い方は前述の|bufname()|を参照。バッファ{expr}
2075                 が存在しないか、ウィンドウが無い場合には-1を返す。例: >
2076
2077         echo "A window containing buffer 1 is " . (bufwinnr(1))
2078
2079 <               この番号は|CTRL-W_w|や":wincmd w"|:wincmd|で使える。
2080                 カレントタブページ内のウィンドウだけを探す。
2081                                                         *byte2line()*
2082 byte2line({byte})
2083                 カレントバッファの先頭から{byte}番目の文字が、何行目に含まれる
2084                 かを返す。これにはカレントバッファの'fileformat'に依存した、改
2085                 行文字も含まれる。先頭の文字にはバイトカウント1が与えられる。
2086                 |line2byte()|と|go|と|:goto|も参照。
2087                 {|+byte_offset|機能付きでコンパイルされたときのみ有効}
2088
2089 byteidx({expr}, {nr})                                   *byteidx()*
2090                 文字列{expr}の{nr}番目の文字のバイトインデックスを返す。
2091                 最初の文字の{nr}は0であり、戻り値は0となる。この関数はマルチバ
2092                 イト文字が存在するときのみ有用であり、そうでなければこの関数が
2093                 返す値は{nr}に等しい。合成文字は別々の文字と数えられる。
2094                 例 : >
2095                         echo matchstr(str, ".", byteidx(str, 3))
2096 <               は4文字目を表示する。次も同じことをする: >
2097                         let s = strpart(str, byteidx(str, 3))
2098                         echo strpart(s, 0, byteidx(s, 1))
2099 <               {expr}が{nr}文字以下の場合は-1を返す。
2100                 {expr}がちょうど{nr}文字の場合は文字列の長さ(バイト単位)を返す。
2101
2102 call({func}, {arglist} [, {dict}])                      *call()* *E699*
2103                 リスト|List|{arglist}の要素を引数として関数{func}を呼ぶ。
2104                 {func}は|Funcref|でも関数の名前でもよい。
2105                 a:firstlineとa:lastlineにはカレント行が代入される。
2106                 呼び出した関数の戻り値を返す。
2107                 {dict}は"dict"属性つきの関数用で、これがローカル変数"self"に代
2108                 入される。|Dictionary-function|を参照。
2109
2110 ceil({expr})                                                    *ceil()*
2111                 {expr} 以上となる最小の整数を浮動小数点数 |Float| で返す
2112                 (切り上げる)。
2113                 {expr} は |Float| か |Number| に評価されなければならない。
2114                 例: >
2115                         echo ceil(1.456)
2116 <                       2.0  >
2117                         echo ceil(-5.456)
2118 <                       -5.0  >
2119                         echo ceil(4.0)
2120 <                       4.0
2121                 {|+float| 機能つきでコンパイルされたときのみ有効}
2122
2123 changenr()                                              *changenr()*
2124                 最も最近の変更の番号を返す。|:undolist|で表示される番号と同じ
2125                 であり、|:undo|コマンドの引数として使うことができる。
2126                 変更を行った直後ではその変更の番号となる。redoを行った直後は
2127                 redoされた変更の番号となる。undoを行った直後はundoされた変更よ
2128                 り1小さい番号になる。
2129
2130                                                         *char2nr()*
2131 char2nr({expr})
2132                 {expr}の最初の文字のASCIIコードを返す。例: >
2133                         char2nr(" ")            returns 32
2134                         char2nr("ABC")          returns 65
2135 <               現在の'encoding'の値が適用される。"utf-8"のときの例: >
2136                         char2nr("á")            returns 225
2137                         char2nr("á"[0]) returns 195
2138 <               |nr2char()| はこの逆を行う。
2139
2140 cindent({lnum})                                         *cindent()*
2141                 'cindent'で使われるのと同じC言語用のインデント規則に従った場合
2142                 の{lnum}行目のインデント量を返す。
2143                 インデント量はスペースで数えられ、'tabstop'の値は関係ない。
2144                 {lnum}は|getline()|の場合と同様に扱われる。
2145                 {lnum}が無効な値のときや|+cindent|機能なしでコンパイルされてい
2146                 るときは-1を返す。
2147                 |C-indenting|を参照。
2148
2149 clearmatches()                                          *clearmatches()*
2150                 |matchadd()| と コマンド |:match| により定義されたマッチをすべ
2151                 て消去する。
2152
2153                                                         *col()*
2154 col({expr})
2155                 戻り値は数値で、{expr}で与えられる位置の桁番号(バイトインデッ
2156                 クス)。有効な位置は:
2157                     .       現在の位置
2158                     $       カレント行の末尾(カレント行のバイト数+1を返す)
2159                     'x      マークxの位置(マークが設定されていない場合0)
2160                 さらに {expr} は [lnum, col] という行番号と桁番号のリストで
2161                 あってもよい。col に "$" を指定して、ある行の最後の桁を取得す
2162                 るのにとても便利である。"lnum" か "col" が範囲外である場合は
2163                 0 を返す。
2164                 行番号を取得するには|line()|を使う。行番号と桁番号両方を取得す
2165                 るには|getpos()|を使う。
2166                 画面上の桁番号を取得するには|virtcol()|を使う。
2167                 Note 現在のファイルのマークしか使えないことに注意。
2168                 例: >
2169                         col(".")                カーソルの桁
2170                         col("$")                カレント行の長さ+1
2171                         col("'t")               マークtの桁
2172                         col("'" . markname)     マークmarknameの桁
2173 <               先頭の桁は1になる。戻り値0はエラーを意味する。
2174                 大文字のマークは他のバッファを指しているかもしれない。
2175                 'virtualedit'が有効なとき、カーソルが行末を越えていると、桁番
2176                 号は行の長さより1大きい値を返す。インサートモードで桁番号を取
2177                 得するには次のマップが使える: >
2178                         :imap <F2> <C-O>:let save_ve = &ve<CR>
2179                                 \<C-O>:set ve=all<CR>
2180                                 \<C-O>:echo col(".") . "\n" <Bar>
2181                                 \let &ve = save_ve<CR>
2182 <
2183 complete({startcol}, {matches})                 *complete()* *E785*
2184                 インサートモード補完の候補を設定する。
2185                 インサートモードでのみ使用できる。CTRL-R = |i_CTRL-R|と組み合
2186                 わせてマッピングを作る必要がある。CTRL-Oの後や、<expr>マッピン
2187                 グの中では正しく動作しない。
2188                 {startcol}は補完すべき単語の開始位置を示す、行内のバイトオフセッ
2189                 トである。その位置からカーソルまでのテキストが補完すべき単語と
2190                 なる。
2191                 {matches}はリスト|List|でなければならない。リストの各要素が1つ
2192                 の候補となる。この要素として許される値については
2193                 |complete-items|を参照。
2194                 Note この関数を呼んだ後は補完を停止させるようなテキストの挿入
2195                 をしないように注意しなければならない。
2196                 この関数で設定した候補は普通のインサートモード補完と同じ様に
2197                 CTRL-NとCTRL-Pで選択できる。設定されていればポップアップメニュー
2198                 が表示される。|ins-completion-menu|を参照。
2199                 例: >
2200         inoremap <F5> <C-R>=ListMonths()<CR>
2201         func! ListMonths()
2202           call complete(col('.'), ['January', 'February', 'March',
2203                 \ 'April', 'May', 'June', 'July', 'August', 'September',
2204                 \ 'October', 'November', 'December'])
2205           return ''
2206         endfunc
2207 <               この例はそれほど役には立たないが、使い方を示している。Note 0が
2208                 挿入されてしまわないように空文字列を返していることに注意。
2209
2210 complete_add({expr})                            *complete_add()*
2211                 候補のリストに{expr}を追加する。'completefunc'で指定された関数
2212                 の中でのみ使われる。
2213                 失敗したときは0を返す(空文字列かメモリ不足)。候補が追加された
2214                 ときは1を返し、その候補が既にリストに存在するときは2を返す。
2215                 {expr}の説明については|complete-functions|を参照。'omnifunc'が
2216                 返すリストと同じである。
2217
2218 complete_check()                                *complete_check()*
2219                 補完候補を探している間にキーがタイプされたかどうか確認する。補
2220                 完の検索に時間がかかる場合に使われる。候補の検索を中断しようと
2221                 しているときは0以外を返す。そうでないときは0を返す。
2222                 'completefunc'で指定された関数の中でのみ使われる。
2223
2224                                                         *confirm()*
2225 confirm({msg}, {choices} [, {default} [, {type}]])
2226                 confirm()はユーザに選択させるためのダイアログを提供する。戻り
2227                 値は選択した番号になる。最初の選択肢が1である。
2228                 Note: confirm()は、ダイアログサポートを有効にしてコンパイルし
2229                 た時にだけ動作する。|+dialog_con|と|+dialog_gui|を参照。
2230                 ダイアログには{msg}に加えて{choices}の選択肢が表示される。
2231                 {choices}が指定されない、または空の場合は選択肢"&OK"が表示され
2232                 る(使用している言語に翻訳される)。
2233                 {msg}は文字列で'\n'を改行として使用できる。幾つかのシステムで
2234                 は、長すぎる行は自動的に折り返される。
2235                 {choices}は文字列で、個々の選択肢は'\n'によって区切られる。
2236                 例: >
2237                         confirm("Save changes?", "&Yes\n&No\n&Cancel")
2238 <               '&'の後の文字は選択肢のショートカットキーになる。この場合
2239                 "Cancel"を選択するのに'c'をタイプすることができる。ショート
2240                 カットキーは最初の文字である必要は無い: >
2241                         confirm("file has been modified", "&Save\nSave &All")
2242 <               コンソールでは、デフォルトのショートカットキーとして、各選択肢
2243                 の最初の文字が使われる。
2244                 省略可能な引数{default}は<CR>キーを叩いた時に選択される選択肢
2245                 の番号を指定する。最初の選択肢をデフォルトにするならば1を使用
2246                 する。デフォルトを設定したくないのならば0を使用する。
2247                 {default}を省略した場合、0が使用される。
2248                 省略可能な引数{type}はダイアログの種類を指定する。これは
2249                 Win32 GUI版でアイコンを指定するのに使う。"Error", "Question",
2250                 "Info", "Warning", "Generic"のうちどれか一つを指定する。以上の
2251                 うちの先頭の文字だけで指定できる。{type}が省略された場合、
2252                 "Generic"が使用される。
2253                 ユーザが<Esc>やCTRL-Cや、その他の割りこみキーでダイアログを中
2254                 断した場合、confirm()は0を返す。
2255
2256                 例: >
2257    :let choice = confirm("What do you want?", "&Apples\n&Oranges\n&Bananas", 2)
2258    :if choice == 0
2259    :    echo "make up your mind!"
2260    :elseif choice == 3
2261    :    echo "tasteful"
2262    :else
2263    :    echo "I prefer bananas myself."
2264    :endif
2265 <               GUIのダイアログではボタンが使用される。ボタンの配置は
2266                 'guioptions'の'v'フラグに依存する。もしも'v'フラグが含まれてい
2267                 るのなら、ボタンは常に垂直に配置される。そうでなければ水平に配
2268                 置しようと試みられる。水平配置がうまくマッチしない場合は、垂直
2269                 配置が使われる。幾つかのシステムでは常に水平配置が使われる。
2270
2271                                                         *copy()*
2272 copy({expr})    {expr}のコピーを作る。数値と文字列の場合は、{expr}そのものとコ
2273                 ピーの間に違いはない。
2274                 {expr}がリスト|List|の場合は浅いコピーを作る。つまり元のリスト
2275                 を変更してもコピーは変更されず、逆も同じである。しかし要素は共
2276                 通で、片方の要素に対し変更を加えると、もう一方の要素も変更され
2277                 る。|deepcopy()|も参照。
2278
2279 cos({expr})                                             *cos()*
2280                 {expr} の余弦(コサイン)をラジアンで浮動小数点数 |Float| で返す。
2281                 {expr} は |Float| または |Number| に評価されなければならない。
2282                 例: >
2283                         :echo cos(100)
2284 <                       0.862319 >
2285                         :echo cos(-4.01)
2286 <                       -0.646043
2287                 {|+float| 機能つきでコンパイルされたときのみ有効}
2288
2289
2290 count({comp}, {expr} [, {ic} [, {start}]])                      *count()*
2291                 リスト|List|または辞書|Dictionary| {comp}の中に値{expr}が何回
2292                 現れるかを返す。
2293                 {start}が指定されたときはそのインデックスの要素から検索を開始
2294                 する。{start}は{comp}がリストの場合のみ使用できる。
2295                 {ic}が指定され、0でない場合は大文字・小文字は区別されない。
2296
2297
2298                                                         *cscope_connection()*
2299 cscope_connection([{num} , {dbpath} [, {prepend}]])
2300                 |cscope|接続が存在するかどうか判定する。引数が1個も指定されな
2301                 かった場合、戻り値は以下のようになる:
2302                         0, cscopeが利用できない(コンパイル時に無効化されている)
2303                            またはcscope接続が存在しない場合
2304                         1, 1個以上のcscope接続が存在する場合
2305
2306                 引数が与えられた場合は次のようになる。{num}は、接続の存在を確
2307                 認する際のマッチング方法を指定する。
2308
2309                 {num}   存在確認の方法
2310                 -----   ------------------------------
2311                 0       引数なしの場合と同じ (例: "cscope_connection()").
2312                 1       {prepend}を無視し、{dbpath}に部分マッチを行う。
2313                 2       {prepend}を無視し、{dbpath}に部分マッチを行う。
2314                 3       {prepend}を使用し、{dbpath}と{prepend}に部分マッチを行
2315                         う。
2316                 4       {prepend}を使用し、{dbpath}と{prepend}に完全マッチを行
2317                         う。
2318
2319                 Note: 以上のどの場合も文字列の比較は大文字・小文字を区別する。
2320
2321                 例: ":cs show"の表示が以下のようになったとする: >
2322
2323   # pid    database name                        prepend path
2324   0 27664  cscope.out                           /usr/local
2325 <
2326                 実行                                              戻り値 ~
2327                 ----------                                      ---------- >
2328                 cscope_connection()                                     1
2329                 cscope_connection(1, "out")                             1
2330                 cscope_connection(2, "out")                             0
2331                 cscope_connection(3, "out")                             0
2332                 cscope_connection(3, "out", "local")                    1
2333                 cscope_connection(4, "out")                             0
2334                 cscope_connection(4, "out", "local")                    0
2335                 cscope_connection(4, "cscope.out", "/usr/local")        1
2336 <
2337 cursor({lnum}, {col} [, {off}])                         *cursor()*
2338 cursor({list})
2339                 {lnum}行目の{col}桁目(バイトで数える)にカーソルを移動させる。
2340                 桁番号{col}は1から始まる。
2341                 引数が1個の場合は、{lnum}, {col}, {off}からなる、2個または3個
2342                 の要素を持つリスト|List|でなければならない。これは|getpos()|の
2343                 戻り値と似ているが、1個目の要素がない点が異なる。
2344                 この関数を呼んでもジャンプリストは変更されない。
2345                 {lnum}がバッファの行数よりも大きい場合は、最後の行へ移動する。
2346                 {lnum}が0の場合はカレント行に留まる。
2347                 {col}がその行のバイト数より大きい場合は、その行の最後の文字へ
2348                 移動する。
2349                 {col}が0の場合は、カレント桁に留まる。
2350                 'virtualedit'が有効のとき、{off}は文字の先頭からの画面上のオフ
2351                 セットを指定する。例えば、<Tab>の中の位置や最後の文字より後な
2352                 どへも移動できる。
2353                 カーソルを移動できたときは 0 を、できなかったときは-1 を返す。
2354
2355 deepcopy({expr}[, {noref}])                             *deepcopy()* *E698*
2356                 {expr}のコピーを作る。数値と文字列の場合は、{expr}そのものとコ
2357                 ピーの間に違いはない。
2358                 {expr}がリスト|List|の場合は完全なコピーを作る。つまり元のリス
2359                 トを変更してもコピーは変更されず、逆も同じである。要素の1つが
2360                 リストであるときは、再帰的にコピーが作成される。よってコピーの
2361                 要素に変更を加えても元のリストの要素は変更を受けない。
2362                 {noref}が省略された、または0のとき、含まれているリストや辞書は
2363                 1度だけコピーされる。全ての参照はこのただ1つのコピーを指す。
2364                 {noref}が1の場合、リストや辞書は現れるたびに新しいコピーが作ら
2365                 れる。そのため循環参照があるとdeepcopy()は失敗する。
2366                                                                 *E724*
2367                 ネストは100レベルまで可能である。それ以上参照を繰り返している
2368                 要素があると、{noref}が1の場合は失敗する。
2369                 |copy()|も参照。
2370
2371                                                         *delete()*
2372 delete({fname}) {fname}という名前のファイルを削除する。戻り値は数値で、削除に
2373                 成功したら0、失敗したら1が返る。
2374                 リスト|List|から要素を削除するには|remove()|を使う。
2375
2376                                                         *did_filetype()*
2377 did_filetype()  autocommandが実行されFileTypeイベントが一度でも起こっていれ
2378                 ば、非零が返る。スクリプトのFileTypeイベントが、複数回呼び出さ
2379                 れるのを回避するのに使える。 |FileType|
2380                 他のファイルへ移動すると、このカウンタはリセットされる。よって
2381                 実際は、カレントバッファに対してFileTypeイベントが発生したかど
2382                 うかを判定する。他のバッファを開くオートコマンドの中でこの関数
2383                 を使って'filetype'を設定し、構文ファイルを読み込むために使える。
2384
2385 diff_filler({lnum})                                     *diff_filler()*
2386                 {lnum}行目より上にある削除行の数を返す。削除行とは、diffモード
2387                 で他方のウィンドウにテキストが挿入されていることを表す行のこと
2388                 である。削除行は表示はされているが、実際にはバッファに存在しな
2389                 い。
2390                 {lnum}は|getline()|と同様に扱われる。つまり"."はカレント行とな
2391                 り、"'m"はマークmを表す。
2392                 カレントウィンドウがdiffモードでないときは0を返す。
2393
2394 diff_hlID({lnum}, {col})                                *diff_hlID()*
2395                 diffモードで{lnum}行{col}桁(バイト単位)の位置のハイライトIDを
2396                 返す。カレント行に変更がないときは0を返す。
2397                 {lnum}は|getline()|と同様に扱われる。つまり"."はカレント行とな
2398                 り、"'m"はマークmを表す。
2399                 先頭の桁の{col}は1となり、最初の行の{lnum}は1となる。
2400                 ハイライトIDは|synIDattr()|を使って構文情報を得るために使える。
2401
2402 empty({expr})                                           *empty()*
2403                 {expr}が空なら1を、そうでなければ0を返す。
2404                 リスト|List|または辞書|Dictionary|は要素を1個も持たないとき空
2405                 とみなされる。数値は値が0のとき空とみなされる。
2406                 長いリストに対しては長さを0と比較するよりこちらの方がずっと高
2407                 速である。
2408
2409 escape({string}, {chars})                               *escape()*
2410                 {string}内に現れる{chars}の文字をバックスラッシュでエスケープ
2411                 する。例: >
2412                         :echo escape('c:\program files\vim', ' \')
2413 <               結果: >
2414                         c:\\program\ files\\vim
2415 <               |shellescape()| も参照。
2416
2417                                                         *eval()*
2418 eval({string})  {string}を評価し、値を返す。|string()|の戻り値を元の値に戻すの
2419                 に非常に便利である。数値、浮動小数点数文字列、それらの複合に対
2420                 して動作する。実際に存在する関数への|Funcref|に対しても動作す
2421                 る。
2422
2423 eventhandler()                                          *eventhandler()*
2424                 イベントハンドラの中では1を返す。つまり、ユーザの文字入力を待っ
2425                 ている間に、ファイルをドラッグ＆ドロップするなど割り込みされた
2426                 ことを表す。このときは対話的なコマンドは使えない。イベントハン
2427                 ドラの中でないときは0を返す。
2428
2429 executable({expr})                                      *executable()*
2430                 {expr}という名前の実行可能ファイルが存在するかどうか判定する。
2431                 {expr}は引数を何もつけないプログラム名でなければならない。
2432                 executable()は$PATHと通常のプログラム検索ディレクトリを参照す
2433                 る。                                      *PATHEXT*
2434                 MS-DOSとMS-Windowsでは".exe"、".bat"などの拡張子は含めても含め
2435                 なくてもよい。省略された場合は$PATHEXTの拡張子を検索する。よっ
2436                 て"foo.exe"が存在しなければ"foo.exe.bat"が見つかることもありう
2437                 る。$PATHEXTが存在しなければ".exe;.com;.bat;.cmd"が使われる。
2438                 $PATHEXTにドットだけを含めると拡張子なしの名前を検索することが
2439                 できる。'shell'がUnixシェルのように思われるときは、{expr}の後
2440                 に拡張子をつけない名前も検索される。
2441                 MS-DOSとMS-Windowsではファイルが存在するかどうかだけを判定し、
2442                 それがディレクトリでないことや、それが本当に実行可能であるかど
2443                 うかは判定されない。
2444                 MS-WindowsではVimと同じディレクトリにある実行ファイルは必ず発
2445                 見できる。Vimがこのディレクトリを$PATHに加えるためである。
2446                 |win32-PATH|。
2447                 戻り値は数値:
2448                         1       存在する
2449                         0       存在しない
2450                         -1      このシステム上では実装されていない
2451
2452                                                         *exists()*
2453 exists({expr})  結果は数値で、変数{expr}が存在すれば1となり、そうでなければ0と
2454                 なる。引数{expr}は文字列で次のうちいずれかである。
2455                         &option-name    Vimオプション(存在するかだけを判定し、
2456                                         本当に動作するかは判定しない)
2457                         +option-name    動作するVimオプション
2458                         $ENVNAME        環境変数(空文字列と比較することでも判
2459                                         定できる)
2460                         *funcname       組み込み関数(|functions|参照)かユーザ
2461                                         が定義した関数(|user-functions|参照)
2462                         varname         内部変数(|internal-variables|)
2463                                         |curly-braces-names|, |Dictionary|の要
2464                                         素、|List|の要素などに対しても動作する。
2465                                         インデックスの評価で無効な式であるとエ
2466                                         ラーメッセージが出る可能性があることに
2467                                         注意。例: >
2468                                            :let l = [1, 2, 3]
2469                                            :echo exists("l[5]")
2470 <                                          0 >
2471                                            :echo exists("l[xx]")
2472 <                                          E121: Undefined variable: xx
2473                                            0
2474                         :cmdname        exコマンド: 組み込みコマンド、ユーザ定
2475                                         義コマンド、コマンド修飾子|:command|。
2476                                         戻り値:
2477                                         1  コマンド名の先頭に一致
2478                                         2  コマンド名に完全一致
2479                                         3  複数のユーザ定義コマンドに一致
2480                                         コマンドが定義されているかどうかを判定
2481                                         するには、必ず戻り値が2であるかを確認
2482                                         すること。
2483                         :2match         |:2match|のコマンド。
2484                         :3match         |:3match|のコマンド。
2485                         #event          このイベントに対するオートコマンド定義
2486                         #event#pattern  このイベントとパターンに対するオートコ
2487                                         マンド定義(パターンは文字そのままに解
2488                                         釈され、オートコマンドのパターンと1文
2489                                         字ずつ比較される)
2490                         #group          オートコマンドグループが存在するか
2491                         #group#event    このグループとイベントに対してオートコ
2492                                         マンドが定義されているか
2493                         #group#event#pattern
2494                                         このグループ、イベント、パターンに対す
2495                                         るオートコマンド定義
2496                         ##event         このイベントに対するオートコマンドがサ
2497                                         ポートされているか
2498                 ある機能がサポートされているか判定するには|has()|を使う。
2499
2500                 例: >
2501                         exists("&shortname")
2502                         exists("$HOSTNAME")
2503                         exists("*strftime")
2504                         exists("*s:MyFunc")
2505                         exists("bufcount")
2506                         exists(":Make")
2507                         exists("#CursorHold")
2508                         exists("#BufReadPre#*.gz")
2509                         exists("#filetypeindent")
2510                         exists("#filetypeindent#FileType")
2511                         exists("#filetypeindent#FileType#*")
2512                         exists("##ColorScheme")
2513 <               シンボルである&/$/*と名前の間には、空白文字があってはならな
2514                 い。
2515                 ある少数の場合では無視されるが、名前の後に余計な文字があっては
2516                 ならない。将来はもっと厳格になる可能性があるので、現在許される
2517                 からといって頼ってはならない。
2518                 正しい例: >
2519                         exists(":make")
2520 <               正しくない例: >
2521                         exists(":make install")
2522
2523 <               Note 引数は変数そのものではなく、文字列でなければならない。例
2524                 えば、次は動作しない: >
2525                         exists(bufcount)
2526 <               これは変数"bufcount"の存在を判定するのではなく、bufcountの値を
2527                 渡し、それが存在するかどうか判定してしまう。
2528
2529                                                         *expand()*
2530 expand({expr} [, {flag}])
2531                 ワイルドカードと{expr}内の特殊なキーワードを展開する。戻り値は
2532                 文字列。
2533
2534                 複数の候補があった場合、それらは文字<NL>で区切られる。[注意:
2535                 バージョン5.0では空白文字が用いられ、スペースを含むファイル名
2536                 について問題を引き起こしていた]
2537
2538                 展開が失敗した場合、結果は空文字列となる。また存在しないファイ
2539                 ル名というのは、結果の文字列には含まれない。
2540
2541                 {expr}が'%'か'#'か'<'で始まる場合には、展開は|cmdline-special|
2542                 のように、変換子を受け付け、それらに関連付けられた変換が施され
2543                 る。ここに簡単な概略を示す:
2544
2545                         %               現在のファイル名
2546                         #               代替バッファのファイル名
2547                         #n              n番の代替バッファのファイル名
2548                         <cfile>         カーソルのしたのファイル名
2549                         <afile>         autocmdのファイル名
2550                         <abuf>          autocmdのバッファ名
2551                         <sfile>         取り込み(source)中のファイル名
2552                         <cword>         カーソル下の単語(word)
2553                         <cWORD>         カーソル下の単語(WORD)
2554                         <client>        最後に受け取ったメッセージの{clientid}
2555                                         |server2client()|
2556                 変換子:
2557                         :p              フルパス名を展開
2558                         :h              ヘッド(ディレクトリ)
2559                         :t              テイル(ファイル名だけ)
2560                         :r              拡張子が削除される
2561                         :e              拡張子だけ
2562
2563                 例: >
2564                         :let &tags = expand("%:p:h") . "/tags"
2565 <               '%'や'#'や'<'で始まる文字列を展開する時には、それに続くテキス
2566                 トは無視されることに注意。従ってこれは正しくない: >
2567                         :let doesntwork = expand("%:h.bak")
2568 <               こうすると良い: >
2569                         :let doeswork = expand("%:h") . ".bak"
2570 <               "<cfile>"やそれらを展開する時には、戻り値が完全な展開をされな
2571                 い参照名であることにも注意が必要。もしも"<cfile>"が"~/.cshrc"
2572                 であった場合、"~/"を展開してホームディレクトリにするために、も
2573                 う一度expand()を呼び出す必要がある: >
2574                         :echo expand(expand("<cfile>"))
2575 <
2576                 変数と変換子の間には空白文字があってはならない。関数
2577                 |fnamemodify()|が通常のファイル名の変換には使用可能である。
2578
2579                 カレントバッファや代替バッファの名前が未定義のときに'%'や'#'を
2580                 使うと空文字列になる。"%:p"を名無しのバッファに使用した場合、
2581                 結果はカレントディレクトリに'/'が付加されたものになる。
2582
2583                 '%'や'#'や'<'で始まらない{expr}は、コマンドラインのファイル名
2584                 と同じように展開される。オプションの{flag}が使用され、その値が
2585                 非ゼロでない時以外は'suffixes'と'wildignore'が使用される。存在
2586                 しないファイルの名前も結果の文字列に含まれる。"**"を使うとディ
2587                 レクトリツリーを検索できる。例えば、カレントディレクトリ以下に
2588                 ある全ての"README"を見つけるには次のようにする: >
2589                         :echo expand("**/README")
2590 <
2591                 expand()は、シェルの持っている変数や環境変数を展開することがで
2592                 きる。しかしシェルを起動しなければならないので、遅くなる。
2593                 |expr-env-expand|を参照。展開された変数はファイル名のリストの
2594                 ように扱われる。環境変数を展開できないときはそのままになる。よっ
2595                 て":echo expand('$FOOBAR')"の結果は"$FOOBAR"となる。
2596
2597                 存在するファイルを探すには|glob()|を参照。外部コマンドの「生
2598                 の」実行結果を扱うには|system()|を参照。
2599
2600 extend({expr1}, {expr2} [, {expr3}])                    *extend()*
2601                 {expr1}と{expr2}は両方ともリスト|List|であるか、両方とも辞書
2602                 |Dictionaries|でなければならない。
2603
2604                 両方ともリストであるなら、{expr2}を{expr1}に付け加える。
2605                 {expr3}が指定された場合は、{expr1}の第{expr3}番目の要素の前に
2606                 {expr2}の要素を挿入する。{expr3}が0のときは最初の要素の前に挿
2607                 入する。{expr3}がlen({expr1})に等しいときは末尾に{expr2}が付け
2608                 加えられる。
2609                 例: >
2610                         :echo sort(extend(mylist, [7, 5]))
2611                         :call extend(mylist, [2, 3], 1)
2612 <               {expr1} が {expr2} と同じリストである場合、コピーされる要素の
2613                 数はリストの元の長さと同じである。
2614                 例として {expr3} が 1 のとき、最初の要素の N 個の新しいコピー
2615                 が挿入される(ここで N はリストの元の長さ)。
2616                 リストに1個の要素を加えるには|add()|を使う。2つのリストを連結
2617                 して新しいリストを作るには演算子+を使う: >
2618                         :let newlist = [1, 2, 3] + [4, 5]
2619 <
2620                 両方とも辞書である場合:
2621                 {expr2}の全要素を{expr1}に加える。
2622                 {expr1}と{expr2}で共通のキーがある場合は、{expr3}によって動作
2623                 が決まる:
2624                 {expr3} = "keep"の場合: {expr1}の値そのままにする
2625                 {expr3} = "force"の場合: use the value of {expr2}
2626                 {expr3} = "error"の場合: エラーメッセージを表示する     *E737*
2627                 {expr3}が省略された場合は"force"と同じになる。
2628
2629                 {expr2}が空でないならば{expr1}が変更される。必要ならば最初に
2630                 {expr1}のコピーを作ること。
2631                 {expr2}は変更されない。
2632                 {expr1}を返す。
2633
2634
2635 feedkeys({string} [, {mode}])                           *feedkeys()*
2636                 {string}中の各文字を、あたかもマッピングまたはユーザによってタ
2637                 イプされたかのように、処理キューに入れる。 これらの文字は先行
2638                 入力バッファの末尾に付け足される。そのためマッピングを展開して
2639                 いる途中であれば、これらの文字はマッピングを展開した後に来るこ
2640                 とになる。
2641                 この関数は、{string}中の文字が処理されるまでは待たない。
2642                 特殊なキーを{string}に含めるにはダブルクォートと"\..."記法を使
2643                 う(|expr-quote|を参照)。例えば、feedkeys("\<CR>")は<Enter>キー
2644                 の押下をシミュレートする。しかしfeedkeys('\<CR>')とすると、こ
2645                 の文字の通り5文字を挿入する。
2646                 {mode}が省略されたときは、挿入されたキーはマップ展開の対象にな
2647                 る。{mode}は以下の文字フラグを含む文字列:
2648                 'm'     キーをマップ展開する。これが既定である。
2649                 'n'     キーをマップ展開しない。
2650                 't'     キーをタイプされたかのように扱う。そうでない場合は
2651                         マッピングから展開されたかのように扱われる。これは
2652                         undoや折り畳みの展開などで違いが現れる。
2653                 戻り値は常に0。
2654
2655                                                         *filereadable()*
2656 filereadable({file})
2657                 結果は数値で、{file}というファイルが存在し、読みこむことが可能
2658                 ならばTRUEとなる。ファイル{file}が存在しないかディレクトリだっ
2659                 た場合には、結果はFALSEとなる。引数{file}は文字列として使えれ
2660                 ばどのような表現でもよい。
2661                 ファイルが読み込み可能でなくてもよい場合には|glob()|を使う。
2662                                                         *file_readable()*
2663                 以前の名前: file_readable().
2664
2665 filewritable({file})                                    *filewritable()*
2666                 結果は数値で、{file}というファイルが存在し、書き込むことが可能
2667                 ならば1となる。ファイル{file}が存在しないか書き込み不可能であ
2668                 る場合には、結果は0となる。{file}がディレクトリであり、書き込
2669                 み可能な場合、結果は2となる。
2670
2671
2672 filter({expr}, {string})                                        *filter()*
2673                 {expr}はリスト|List|または辞書|Dictionary|でなければならない。
2674                 {expr}の各要素に対して{string}を評価し、その結果が0ならばリス
2675                 トまたは辞書からその要素を削除する。{string}の内部では|v:val|
2676                 が現在の要素の値を保持している。
2677                 辞書の場合は|v:key|が現在の要素のキーを保持している。
2678                 例: >
2679                         :call filter(mylist, 'v:val !~ "OLD"')
2680 <               は要素"OLD"を削除する。 >
2681                         :call filter(mydict, 'v:key >= 8')
2682 <               は8未満のキーを持つ要素を削除する。 >
2683                         :call filter(var, 0)
2684 <               は全要素を削除する。つまりリストまたは辞書をクリアする。
2685
2686                 Note {string}は式を表す文字列である。バックスラッシュを二重に
2687                 しなくても済むように|literal-string|を使うとよいだろう。
2688
2689                 この操作はその場で(in-place)行われる。リストや辞書を変更したく
2690                 ない場合は最初にコピーを作ること: >
2691                         :let l = filter(copy(mylist), 'v:val =~ "KEEP"')
2692
2693 <               フィルタされたリストまたは辞書を返す。{string}を評価している最
2694                 中にエラーが発生した場合は、それ以降の要素の処理は行われない。
2695
2696
2697 finddir({name}[, {path}[, {count}]])                            *finddir()*
2698                 {path}から{name}という名前のディレクトリを探す。ディレクトリを
2699                 上方・下方のどちらにも再帰的に検索できる。{path}の記法について
2700                 は|file-searching|を参照。
2701                 最初に見つかったディレクトリのパスを返す。そのディレクトリがカ
2702                 レントディレクトリの下にある場合は相対パスを返す。そうでなけれ
2703                 ば絶対パスを返す。
2704                 {path}が省略されたとき、または空のときはオプション'path'の値が
2705                 使われる。
2706                 省略可能な引数{count}が指定されたときは、最初に見つかったディ
2707                 レクトリでなく、{count}番目に見つかったディレクトリを返す。
2708                 {count}が負の場合は、見つかったディレクトリ全てのリスト|List|
2709                 を返す。これはexコマンド|:find|によく似ている。
2710                 {+file_in_path機能付きでコンパイルされたときのみ利用可能}
2711
2712 float2nr({expr})                                        *float2nr()*
2713                 {expr} の小数点以下を切り捨てて |Number| に変換する。
2714                 {expr} は |Float| または |Number| に評価されなければならない。
2715                 {expr} の値が |Number| の範囲外の場合、結果は 0x7fffffff また
2716                 は -0x7fffffff になる。NaN は -0x80000000 になる。
2717                 例: >
2718                         echo float2nr(3.95)
2719 <                       3  >
2720                         echo float2nr(-23.45)
2721 <                       -23  >
2722                         echo float2nr(1.0e100)
2723 <                       2147483647  >
2724                         echo float2nr(-1.0e150)
2725 <                       -2147483647  >
2726                         echo float2nr(1.0e-100)
2727 <                       0
2728                 {|+float| 機能つきでコンパイルされたときのみ有効}
2729
2730
2731 floor({expr})                                                   *floor()*
2732                 {expr} 以下の最大の整数を |Float| で返す(切り捨て)。
2733                 {expr} は |Float| または |Number| に評価されなければならな
2734                 い。
2735                 例: >
2736                         echo floor(1.856)
2737 <                       1.0  >
2738                         echo floor(-5.456)
2739 <                       -6.0  >
2740                         echo floor(4.0)
2741 <                       4.0
2742                 {|+float| 機能つきでコンパイルされたときのみ有効}
2743
2744 fnameescape({string})                                   *fnameescape()*
2745                 コマンド引数のファイル名として使うために {string} をエスケープ
2746                 する。'%' や '|' など特別な意味を持つ全ての文字がバックスラッ
2747                 シュでエスケープされる。
2748                 特別な文字とは、ほとんどのシステムにおいて
2749                 " \t\n*?[{`$\\%#'\"|!<" である。ファイル名にバックスラッシュが
2750                 現れるシステムにおいては 'isfname' の値に依存する。
2751                 先頭の '+' と '>' もエスケープされる(|:edit| と |:write| の引
2752                 数では特別な意味を持つ)。{string} が "-" である場合もエスケー
2753                 プされる(|:cd| の引数では意味を持つ)。
2754                 例: >
2755                         :let fname = '+some str%nge|name'
2756                         :exe "edit " . fnameescape(fname)
2757 <               上記は次と同じ結果になる: >
2758                         edit \+some\ str\%nge\|name
2759
2760 findfile({name}[, {path}[, {count}]])                           *findfile()*
2761                 |finddir()|と同様だが、ディレクトリでなくファイルを検索する。
2762                 'suffixesadd'が適用される。
2763                 例: >
2764                         :echo findfile("tags.vim", ".;")
2765 <               この例は、カレントファイルがあるディレクトリから上方に
2766                 "tags.vim"を見つけるまで再帰的に検索する。
2767
2768                                                         *fnamemodify()*
2769 fnamemodify({fname}, {mods})
2770                 ファイル名{fname}を{mods}にしたがって変更する。{mods}はコマン
2771                 ドラインで使われるのと同様な文字列である。詳細は
2772                 |filename-modifiers|を参照。
2773                 例: >
2774                         :echo fnamemodify("main.c", ":p:h")
2775 <               結果: >
2776                         /home/mool/vim/vim/src/
2777 <               Note: {fname}の中の環境変数は展開されない。環境変数を展開させ
2778                 るには|expand()|を使うこと。
2779
2780 foldclosed({lnum})                                      *foldclosed()*
2781                 結果は数値。{lnum}行目が閉じた折り畳みの中にあるなら、その折り
2782                 畳みを構成する最初の行の行番号を返す。{lnum}行目が閉じた折り畳
2783                 みに入っていないなら-1を返す。
2784
2785 foldclosedend({lnum})                                   *foldclosedend()*
2786                 結果は数値。{lnum}行目が閉じた折り畳みの中にあるなら、その折り
2787                 畳みを構成する最後の行の行番号を返す。{lnum}行目が閉じた折り畳
2788                 みに入っていないなら-1を返す。
2789
2790 foldlevel({lnum})                                       *foldlevel()*
2791                 カレントバッファの{lnum}行目の折り畳みレベルを表す数値を返す。
2792                 折り畳みがネストしているときは一番下のレベルを返す。{lnum}行目
2793                 に折り畳みがまったくないときは0を返す。折り畳みが開いているか
2794                 閉じているかは関係ない。('foldexpr'の中で)折り畳みを更新してい
2795                 る最中に呼ぶと、まだ折り畳みを更新していなく、折り畳みレベルが
2796                 未知の行に対しては-1を返す。特別な場合として、普通は1行前のレ
2797                 ベルは取得できる。
2798
2799                                                         *foldtext()*
2800 foldtext()      閉じた折り畳みに表示する文字列を返す。これはオプション
2801                 'foldtext'のデフォルトの関数であり、'foldtext'を評価していると
2802                 きにだけ呼ぶようにすべきである。この関数は変数|v:foldstart|,
2803                 |v:foldend|, |v:folddashes|を使用する。
2804                 戻り値の文字列は次のようになる: >
2805                         +-- 45 lines: abcdef
2806 <
2807                 ダッシュ(-)の数は折り畳みレベルによって決まる。"45"はその折り
2808                 畳みに含まれている行数である。"abcdef"はその折り畳みの中の最初
2809                 の空行でない行のテキストである。行頭の空白と、"//"や/*"、
2810                 'foldmarker'と'commentstring'に設定されている文字列は削除され
2811                 る。
2812                 {|+folding|機能付きでコンパイルされたときのみ利用可能}
2813
2814 foldtextresult({lnum})                                  *foldtextresult()*
2815                 {lnum}行目の閉じた折り畳みに表示される文字列を返す。'foldtext'
2816                 を適切なコンテキストの中で評価する。{lnum}行目に閉じた折り畳み
2817                 がないときは空文字列を返す。
2818                 {lnum}は|getline()|のときと同様に扱われる。つまり"."はカレント
2819                 行、"'m"はマークmを表す。
2820                 折り畳まれたテキストをHTMLなどにエクスポートするときに有用。
2821                 {|+folding|機能付きでコンパイルされたときのみ利用可能}
2822
2823                                                         *foreground()*
2824 foreground()    Vimのウィンドウを前面に移動する。この関数はクライアントからVim
2825                 サーバへ送ると便利である。|remote_send()|
2826                 Win32では自分自身のウィンドウを前面に持ってくることが必ずしも
2827                 許可されていないので、動作しないかもしれない。そのときは代わり
2828                 に|remote_foreground()|を使うこと。
2829                 {Win32, Athena, Motif, GTKいずれかのGUI版とWin32コンソール版で
2830                 のみ利用できる}
2831
2832
2833 function({name})                                        *function()* *E700*
2834                 関数{name}を参照する|Funcref|の変数を返す。{name}はユーザ定義
2835                 関数でも組み込み関数でもよい。
2836
2837
2838 garbagecollect([at_exit])                               *garbagecollect()*
2839                 循環参照を持ち、使われていないリスト|List|と辞書|Dictionaries|
2840                 をクリーンアップする。これはメモリ不足に陥ったときや、
2841                 'updatetime'経過後ユーザのキー入力を待っているときに自動的に行
2842                 われるので、この関数を呼ぶ必要があることはほとんどない。
2843                 循環参照を持たない要素は、使われなくなったとき必ず解放される。
2844                 長時間実行されるスクリプトの中で循環参照を持つ非常に大きなリス
2845                 トや辞書を削除したときに有用である。
2846                 省略可能な引数 "at_exit" に 1 を指定すると、Vim を終了するとき
2847                 にもガベージコレクションが行われる。これはメモリリークを発見す
2848                 るのに役に立つ。
2849
2850 get({list}, {idx} [, {default}])                        *get()*
2851                 リスト|List| {list}から{idx}番目の要素を取得する。この要素を取
2852                 得できないときは{default}を返す。{default}が省略されたときは0
2853                 を返す。
2854 get({dict}, {key} [, {default}])
2855                 辞書|Dictionary| {dict}からキー{key}に関連づけられた値を取得す
2856                 る。この要素を取得できないときは{default}を返す。{default}が省
2857                 略されたときは0を返す。
2858
2859                                                         *getbufline()*
2860 getbufline({expr}, {lnum} [, {end}])
2861                 バッファ{expr}の{lnum}行目から{end}行目まで(両端含む)の行から
2862                 なるリスト|List|を返す。{end}が省略されたときは{lnum}行目だけ
2863                 からなるリストを返す。
2864
2865                 {expr}の指定の仕方については|bufname()|を参照。
2866
2867                 {lnum}と{end}では"$"でバッファの最後の行を表すことができる。そ
2868                 れ以外は数値でなければならない。
2869
2870                 {lnum}が1より小さいときや、バッファの行数より大きいときは空リ
2871                 ストを返す。
2872
2873                 {end}がバッファの行数より大きいときは、バッファの行数が設定さ
2874                 れたものとして扱う。{end}が{lnum}行目より前に設定された場合は
2875                 空リストを返す。
2876
2877                 この関数は読み込まれているバッファに対してのみ動作する。既にア
2878                 ンロードされているバッファや存在しないバッファに対しては空リス
2879                 トを返す。
2880
2881                 例: >
2882                         :let lines = getbufline(bufnr("myfile"), 1, "$")
2883
2884 getbufvar({expr}, {varname})                            *getbufvar()*
2885                 バッファ{expr}のオプションの値やバッファローカル変数{varname}
2886                 の値を返す。Note "b:"をつけない変数名を指定すること。
2887                 {varname} が空文字列の場合、全てのバッファローカル変数からなる
2888                 辞書を返す。
2889                 グローバルオプション、バッファローカルオプションのどちらに対し
2890                 ても動作するが、グローバル変数、ウィンドウローカル変数、ウィン
2891                 ドウローカルオプションに対しては動作しない。
2892                 {expr}の指定の仕方については|bufname()|を参照。
2893                 バッファや変数が存在しないときは空文字列を返し、エラーメッセー
2894                 ジは表示されない。
2895                 例: >
2896                         :let bufmodified = getbufvar(1, "&mod")
2897                         :echo "todo myvar = " . getbufvar("todo", "myvar")
2898 <
2899 getchar([expr])                                         *getchar()*
2900                 ユーザまたは入力ストリームから1文字を取得する。
2901                 [expr]が省略されたときは1文字を取得できるまで待つ。
2902                 [expr]が0のときは1文字を取得できる場合のみ取得する。取得できな
2903                 ければ0を返す。
2904                 [expr]が1のときは1文字を取得できるか判定し、実際には取得しない。
2905                 取得できないときは0を返す。
2906
2907                 {expr}が省略されたときや{expr}が0のときは、文字全体または特殊
2908                 キーを返す。それが8ビット文字なら戻り値は数値である。これを文
2909                 字列に戻すにはnr2char()を使う。8ビット文字でないならばエンコー
2910                 ドして文字列にして返す。
2911                 特殊キーとは0x80(10進数で128)で始まるバイト列である。これは
2912                 文字列"\<Key>"と同じ値である(例: "\<Left>")。戻り値は文字列で
2913                 あり、修飾キー(shift, contro, alt)は含まれない。
2914
2915                 {expr}が1のときは最初のバイトだけを返す。1バイト文字の場合、こ
2916                 れはその文字そのものを表す数値である。これを文字列に変換するに
2917                 はnr2char()を使う。
2918
2919                 ユーザがマウスをクリックしたときはマウスイベントを返す。クリッ
2920                 クした位置は|v:mouse_col|, |v:mouse_lnum|, |v:mouse_win|で得ら
2921                 れる。以下の例は、普通にマウスがクリックされたときと同じように
2922                 カーソルを移動させる。 >
2923                         let c = getchar()
2924                         if c == "\<LeftMouse>" && v:mouse_win > 0
2925                           exe v:mouse_win . "wincmd w"
2926                           exe v:mouse_lnum
2927                           exe "normal " . v:mouse_col . "|"
2928                         endif
2929 <
2930                 この関数を呼んだときプロンプトは表示されない。文字入力を待って
2931                 いることをなんらかの方法でユーザがわかるようにしなければならな
2932                 いだろう。
2933                 入力された文字に対してマッピングは適用されない。
2934                 キーコードは置換される。つまりユーザが<Del>を押した場合、「生
2935                 の」文字シーケンスでなく<Del>キーに対応するコードが得られる。
2936                 例: >
2937                         getchar() == "\<Del>"
2938                         getchar() == "\<S-Left>"
2939 <               以下の例は大文字・小文字を区別しないように"f"を再定義する: >
2940                         :nmap f :call FindChar()<CR>
2941                         :function FindChar()
2942                         :  let c = nr2char(getchar())
2943                         :  while col('.') < col('$') - 1
2944                         :    normal l
2945                         :    if getline('.')[col('.') - 1] ==? c
2946                         :      break
2947                         :    endif
2948                         :  endwhile
2949                         :endfunction
2950
2951 getcharmod()                                            *getcharmod()*
2952                 最後にgetchar()などで得た文字に対する修飾キーの状態を表す数値
2953                 を返す。以下の値の和となる:
2954                         2       shift
2955                         4       control
2956                         8       alt (meta)
2957                         16      マウスダブルクリック
2958                         32      マウストリプルクリック
2959                         64      マウスクアドラプルクリック
2960                         128     Macintoshのみ: command
2961                 文字自身に含まれていない修飾キーのみ取得できる。つまり、
2962                 Shift-aは修飾キーなしの"A"となる。
2963
2964 getcmdline()                                            *getcmdline()*
2965                 現在のコマンドラインの内容を取得する。コマンドラインを編集して
2966                 いるときのみ動作する。つまり|c_CTRL-\_e|または|c_CTRL-R_=|を使っ
2967                 ているときのみ有効。
2968                 例: >
2969                         :cmap <F7> <C-\>eescape(getcmdline(), ' \')<CR>
2970 <               |getcmdtype()|, |getcmdpos()|, |setcmdpos()|も参照。
2971
2972 getcmdpos()                                             *getcmdpos()*
2973                 コマンドラインにおけるカーソル位置をバイト単位で取得する。最初
2974                 の桁は1となる。コマンドラインを編集しているときのみ動作する。
2975                 つまり|c_CTRL-\_e|または|c_CTRL-R_=|を使っているときのみ有効。
2976                 |getcmdtype()|, |setcmdpos()|, |getcmdline()|も参照。
2977
2978 getcmdtype()                                            *getcmdtype()*
2979                 現在のコマンドラインの種類を返す。戻り値は次のいずれか:
2980                     :   通常のexコマンド
2981                     >   デバッグモードコマンド |debug-mode|
2982                     /   前方検索コマンド
2983                     ?   後方検索コマンド
2984                     @   |input()| コマンド
2985                     -   |:insert| または |:append| コマンド
2986                 コマンドラインを編集しているときのみ動作する。つまり
2987                 |c_CTRL-\_e|または|c_CTRL-R_=|を使っているときのみ有効。そうで
2988                 ないときは空文字列を返す。
2989                 |getcmdpos()|, |setcmdpos()|, |getcmdline()|も参照。
2990
2991                                                         *getcwd()*
2992 getcwd()        結果は文字列で、現在のディレクトリ名。
2993
2994 getfsize({fname})                                       *getfsize()*
2995                 結果は数値で、{fname}で指定されるファイルのサイズをバイト単位
2996                 で返す。
2997                 {fname}がディレクトリのときは0を返す。
2998                 ファイル{fname}が見つからないときは-1を返す。
2999                 {fname} のサイズが |Number| の範囲外の場合は -2 を返す。
3000
3001 getfontname([{name}])                                   *getfontname()*
3002                 引数なしで使われた場合には現在の通常のフォント名を返す。ハイラ
3003                 イトグループNormalに対して使われるものと同様|hl-Normal|。
3004                 引数が指定された場合には{name}が有効なフォント名であるか判定さ
3005                 れる。有効でないときは空文字列を返す。
3006                 有効なときは実際のフォント名を返す。またはGUIが実際の名前の取
3007                 得をサポートしていないときは{name}をそのまま返す。
3008                 GUIモードで実行しているときのみ動作する。よってvimrcやgvimrcの
3009                 中では使えない。GUIモードが起動した直後にこの関数を呼ぶには、
3010                 オートコマンド|GUIEnter|を使うこと。
3011                 Note GTK 2のGUIはどんなフォント名でも受け付けてしまうため、名
3012                 前が有効であるかのチェックは動作しない。
3013
3014 getfperm({fname})                                       *getfperm()*
3015                 {fname}で指定されたファイルの読み込み、書き込み、実行の許可属
3016                 性を示す文字列を返す。
3017                 {fname}が存在しない、またはそのディレクトリが読み込み不可能な
3018                 ときは空文字列を返す。
3019                 戻り値は"rwxrwxrwx"の形で、"rwx"フラグの各グループは順にファイ
3020                 ルの所有者、ファイルが所属するグループ、その他のユーザを表す。
3021                 許可属性が与えられていないフラグは"-"で置き換えられる。例: >
3022                         :echo getfperm("/etc/passwd")
3023 <               この例は、(セキュリティの観点から望ましい設定がされているなら
3024                 ば)"rw-r--r--"あるいは"rw-------"と表示する。
3025
3026                                                         *getftime()*
3027 getftime({fname})
3028                 結果は{fname}で与えられたファイルの、最終更新時間を示す数値。
3029                 1970年1月1日からの経過時間(秒)で、strftime()に渡すことができる
3030                 だろう。|localtime()|と|strftime()|も参照。
3031                 ファイル{fname}が見つからなかった場合には-1を返す。
3032
3033 getftype({fname})                                       *getftype()*
3034                 {fname}で指定されたファイルの種別を示す文字列を返す。
3035                 {fname}が存在しないときは空文字列を返す。
3036                 ファイルの種別とそれらの結果の表を以下に示す:
3037                         通常ファイル          "file"
3038                         ディレクトリ          "dir"
3039                         シンボリックリンク       "link"
3040                         ブロックデバイス        "bdev"
3041                         キャラクタデバイス       "cdev"
3042                         ソケット            "socket"
3043                         FIFO                    "fifo"
3044                         それ以外            "other"
3045                 例: >
3046                         getftype("/home")
3047 <               Note "link"などの種別はそれをサポートしているシステムでのみ返
3048                 される。"dir"と"file"しか返らないシステムもある。
3049
3050                                                         *getline()*
3051 getline({lnum} [, {end}])
3052                 {end}が指定されない場合は、カレントバッファの{lnum}行目の内容
3053                 を文字列にして返す。例: >
3054                         getline(1)
3055 <               {lnum}が数字ではない文字で始まる文字列であった場合、line()に
3056                 よってその文字列が数字に変換される。よって、カーソルのある行の
3057                 文字列を取得するには: >
3058                         getline(".")
3059 <               {lnum}が1より小さいかバッファの行数よりも大きい数値の場合、空
3060                 文字列が返される。
3061
3062                 {end}が指定された場合は、カレントバッファの{lnum}行目から
3063                 {end}行目までを要素とするリスト|List|を返す。
3064                 {end}は{lnum}と同様に解釈される。
3065                 存在しない行は省略され、エラーメッセージは表示されない。
3066                 {end}が{lnum}より前になる場合は空リストを返す。
3067                 例: >
3068                         :let start = line('.')
3069                         :let end = search("^$") - 1
3070                         :let lines = getline(start, end)
3071
3072 <               他のバッファの行を取得するには|getbufline()|を参照。
3073
3074 getloclist({nr})                                        *getloclist()*
3075                 ウィンドウ{nr}のロケーションリストの全項目からなるリストを返す。
3076                 {nr}に0を指定するとカレントウィンドウになる。ロケーションリス
3077                 トウィンドウに対して使用すると、そこに表示されているロケーショ
3078                 ンリストが返る。ウィンドウ番号{nr}が無効な場合は、空リストが返
3079                 る。それ以外は|getqflist()|と同じ。
3080
3081 getmatches()                                            *getmatches()*
3082                 |matchadd()| と |:match| により定義された全てのマッチの |List|
3083                 を返す。|setmatches()| は |getmatches()| で保存されたマッチの
3084                 リストを復元できるので、|getmatches()| と |setmatches()| は組
3085                 み合わせて使うと便利である。
3086                 例: >
3087                         :echo getmatches()
3088 <                       [{'group': 'MyGroup1', 'pattern': 'TODO',
3089                         'priority': 10, 'id': 1}, {'group': 'MyGroup2',
3090                         'pattern': 'FIXME', 'priority': 10, 'id': 2}] >
3091                         :let m = getmatches()
3092                         :call clearmatches()
3093                         :echo getmatches()
3094 <                       [] >
3095                         :call setmatches(m)
3096                         :echo getmatches()
3097 <                       [{'group': 'MyGroup1', 'pattern': 'TODO',
3098                         'priority': 10, 'id': 1}, {'group': 'MyGroup2',
3099                         'pattern': 'FIXME', 'priority': 10, 'id': 2}] >
3100                         :unlet m
3101 <
3102 getqflist()                                             *getqflist()*
3103                 現在の全quickfixエラーのリストを返す。リストの各要素は辞書で、
3104                 以下の要素を持つ:
3105                         bufnr   ファイル名を持つバッファの番号。その名前を取得
3106                                 するにはbufname()を使う。
3107                         lnum    バッファ中の行番号(最初の行は1)
3108                         col     桁番号(最初の桁は1)
3109                         vcol    0以外: "col"は画面上の桁
3110                                 0: "col"はバイトインデックス
3111                         nr      エラー番号
3112                         pattern エラーの位置を特定するために使う検索パターン
3113                         text    エラーの説明
3114                         type    エラーメッセージの種類。'E', '1'など。
3115                         valid   0以外: エラーメッセージが認識されている
3116
3117                 エラーリストがまったくないか、空であるときは空リストを返す。
3118                 存在しないバッファ番号を持つquickfixリストの項目は"bufnr"を0に
3119                 して返される。
3120
3121                 役に立つ応用例: 複数のファイルから正規表現検索を行い、見つかっ
3122                 たものに対してなんらかの操作をする: >
3123                         :vimgrep /theword/jg *.c
3124                         :for d in getqflist()
3125                         :   echo bufname(d.bufnr) ':' d.lnum '=' d.text
3126                         :endfor
3127
3128 getreg([{regname} [, 1]])                               *getreg()*
3129                 レジスタ{regname}の中身を文字列にして返す。例: >
3130                         :let cliptext = getreg('*')
3131 <               getreg('=')は最後に評価した式レジスタの値を返す。(マップの中で
3132                 使用する)。
3133                 getreg('=', 1)はその式そのものを返す。これを使って|setreg()|で
3134                 復元することができる。他のレジスタの場合は、この引数は無視され
3135                 るので、常に指定していても害はない。
3136                 {regname}を指定しないときは|v:register|が使われる。
3137
3138
3139 getregtype([{regname}])                                 *getregtype()*
3140                 レジスタ{regname}の種類を表す文字列を返す。
3141                 戻り値は次のいずれかとなる:
3142                     "v"                 文字指向|characterwise|の場合
3143                     "V"                 行指向|linewise|の場合
3144                     "<CTRL-V>{width}"   矩形指向|blockwise-visual|の場合
3145                     0                   空、または未知のレジスタの場合
3146                 <CTRL-V>は値0x16の1文字である。
3147                 {regname}を指定しないときは|v:register|が使われる。
3148
3149 gettabwinvar({tabnr}, {winnr}, {varname})               *gettabwinvar()*
3150                 タブページ{tabnr}内のウィンドウ{winnr}のウィンドウローカル変数
3151                 {varname}の値を取得する。
3152                 {varname}が文字"&"で始まるときはウィンドウローカルオプションの
3153                 値を取得する。
3154                 タブページ番号は1から始まる。カレントタブページを指定するには
3155                 |getwinvar()|を指定する。
3156                 {winnr}が0のときはカレントウィンドウとなる。
3157                 グローバルオプション、バッファローカルオプション、ウィンドウロ
3158                 ーカルオプションに対しても動作するが、グローバル変数やバッファ
3159                 ローカル変数に対しては動作しない。
3160                 {varname}が空のときは全ウィンドウローカル変数からなる辞書を返
3161                 す。
3162                 Note {varname}は"w:"をつけずに指定しなければならない。
3163                 例: >
3164                         :let list_is_on = gettabwinvar(1, 2, '&list')
3165                         :echo "myvar = " . gettabwinvar(3, 1, 'myvar')
3166 <
3167
3168                                                         *getwinposx()*
3169 getwinposx()    結果はGUIのVimウィンドウの左端の、デスクトップ上でのX座標値(数
3170                 値)。情報が存在しない(コンソールの)場合は-1となる。
3171
3172                                                         *getwinposy()*
3173 getwinposy()    結果はGUIのVimウィンドウの上端の、デスクトップ上でのY座標値(数
3174                 値)。情報が存在しない(コンソールの)場合は-1となる。
3175
3176 getwinvar({winnr}, {varname})                           *getwinvar()*
3177                 カレントタブページに対する|gettabwinvar()|と同様。
3178                 例: >
3179                         :let list_is_on = getwinvar(2, '&list')
3180                         :echo "myvar = " . getwinvar(1, 'myvar')
3181
3182 glob({expr} [, {flag}])                                 *glob()*
3183                 {expr}内のファイル名のワイルドカードを展開する。特殊文字につい
3184                 ては|wildcards|を参照。結果は文字列。
3185                 結果が複数存在する場合、各々が文字<NL>によって区切られる。
3186                 {flag} に非零を指定しない限り、'suffixes' と 'wildignore' が適
3187                 用される。つまり'wildignore' のパターンにマッチする名前はス
3188                 キップされ、'suffixes' がマッチの順番に影響を与える。
3189                 展開が失敗した場合、結果は空文字列。結果には、存在しないファイ
3190                 ル名は含まれない。
3191
3192                 多くのシステムではバッククォート(「`」という文字のこと)を、外
3193                 部コマンドの実行結果からファイル名を取得するために使用できる。
3194                 例: >
3195                         :let tagfiles = glob("`find . -name tags -print`")
3196                         :let &tags = substitute(tagfiles, "\n", ",", "g")
3197 <               バッククォート内のプログラムの実行結果は、一行に一つずつの項目
3198                 が含まれてなければならない。項目内のスペースは許容される。
3199
3200                 特殊なVimの変数を展開するためには|expand()|を参照。外部コマン
3201                 ドの生の出力を得るためには|system()|を参照。
3202
3203 globpath({path}, {expr} [, {flag}])                     *globpath()*
3204                 {path}の中の全ディレクトリに対して|glob()|を実行し、結果を連結
3205                 する。例: >
3206                         :echo globpath(&rtp, "syntax/c.vim")
3207 <               {path}はコンマ区切りのディレクトリのリスト。各ディレクトリを
3208                 {expr}の前に付加し、glob()と同様にそれを展開する。必要に応じて
3209                 パスの区切り文字が挿入される。
3210                 ディレクトリ名の中にコンマを含めるには、バックスラッシュでエス
3211                 ケープすること。Note MS-Windowsではディレクトリ名の末尾にバッ
3212                 クスラッシュがつくことがある。その後に区切りのコンマを書くとエ
3213                 スケープと見なされてしまうので、バックスラッシュは削除すること。
3214                 どれかのディレクトリに対して展開が失敗してもエラーメッセージは
3215                 表示されない。
3216                 {flag} に非零が指定されない限り、オプション'wildignore'が適用
3217                 される。つまり、'wildignore'のパターンにマッチする名前はスキッ
3218                 プされる。
3219
3220                 "**"を使ってディレクトリツリーを再帰的に検索することができる。
3221                 例えば、'runtimepath'とそれ以下のディレクトリから全ての
3222                 "README.txt"を探すには次のようにする: >
3223                         :echo globpath(&rtp, "**/README.txt")
3224 <               上向き検索と、"**" の深さの限界はサポートされていない。よって
3225                 オプション 'path' の値をそのまま使うとうまく動かないことが
3226                 ある。
3227
3228                                                         *has()*
3229 has({feature})  結果は機能{feature}がサポートされる場合1、されない場合0とな
3230                 る。引数{feature}は文字列。下記の|feature-list|を参照。
3231                 |exists()|も参照。
3232
3233 has_key({dict}, {key})                                  *has_key()*
3234                 結果は数値で、辞書|Dictionary| {dict}がキー{key}の要素を持つな
3235                 ら1、持たないなら0となる。
3236
3237 haslocaldir()                                           *haslocaldir()*
3238                 結果は数値でカレントウィンドウが|:lcd|によってローカルなカレン
3239                 トディレクトリを持つようセットされているなら1、そうでないなら
3240                 0となる。
3241
3242 hasmapto({what} [, {mode} [, {abbr}]])                  *hasmapto()*
3243                 結果は数値。右辺側(マップした先)の一部分に{what}を含むマッピン
3244                 グが存在し、それが{mode}で指定されたモードのいずれかで定義され
3245                 ているなら1を返す。
3246                 {abbr}が指定されていて0でないときはマッピングでなく短縮入力の
3247                 存在を判定する。インサートモードまたはコマンドモードを指定する
3248                 ことを忘れないように。
3249                 グローバルマップとバッファローカルマップの両方をチェックする。
3250                 マッピングが1個も見つからなかったときは0を返す。
3251                 {mode}に対しては以下の文字が利用できる:
3252                         n       ノーマルモード
3253                         v       ビジュアルモード
3254                         o       オペレータ待機モード (Operator-pending)
3255                         i       インサートモード
3256                         l       Language-Argumentモード ("r", "f", "t"など)
3257                         c       コマンドラインモード
3258                 {mode}が省略されたときは"nvo"となる。
3259
3260                 この関数はVimスクリプトの中で、ある関数へのマッピングが既に存
3261                 在するか判定するために有用である。例: >
3262                         :if !hasmapto('\ABCdoit')
3263                         :   map <Leader>d \ABCdoit
3264                         :endif
3265 <               この例は、"\ABCdoit"へのマッピングが存在しないときだけ
3266                 "\ABCdoit"へのマッピングを作成する。
3267
3268 histadd({history}, {item})                              *histadd()*
3269                 文字列{item}を履歴{history}に追加する。履歴{history}は以下のう
3270                 ちどれか一つから選択:                     *hist-names*
3271                         "cmd"    or ":"   コマンドライン履歴
3272                         "search" or "/"   検索パターン履歴
3273                         "expr"   or "="   タイプされた式の履歴
3274                         "input"  or "@"   input()の履歴
3275                 {item}が履歴内に既に存在する場合、それが最新の項目の位置へシフ
3276                 トされる。結果は数値:操作が成功した場合1、そうでなければ0
3277
3278                 例: >
3279                         :call histadd("input", strftime("%Y %b %d"))
3280                         :let date=input("Enter date: ")
3281 <               サンドボックス|sandbox|の中では利用できない。
3282
3283 histdel({history} [, {item}])                           *histdel()*
3284                 {history}の内容を削除する。例えば総てのエントリを消すこともで
3285                 きる。{history}の部分に可能な値は|hist-names|を参照。
3286
3287                 パラメータ{item}が文字列に評価される場合、これは正規表現と
3288                 して扱われる。その表現にマッチする総てのエントリがhistoryから
3289                 削除される(複数あっても)。
3290                 "\c"をつけない場合、大文字・小文字が一致しなければならない。
3291                 |/\c|。
3292                 {item}が数値に評価される場合、インデックスとして解釈される。イ
3293                 ンデックスについては|:history-indexing|を参照。関連するエント
3294                 リ(訳注:The respective entry)も、存在すれば削除される。
3295
3296                 結果は数値: 削除に成功すれば1を、そうでなければ0が返る。
3297
3298                 例:
3299                 式レジスタの履歴を削除する: >
3300                         :call histdel("expr")
3301 <
3302                 検索履歴から、"*"で始まるエントリを総て削除する: >
3303                         :call histdel("/", '^\*')
3304 <
3305                 次の3つは等価である: >
3306                         :call histdel("search", histnr("search"))
3307                         :call histdel("search", -1)
3308                         :call histdel("search", '^'.histget("search", -1).'$')
3309 <
3310                 最後の検索パターンを削除し、一つ前のパターンを"n"コマンド(次の
3311                 マッチへ移動)と'hlsearch'の為に設定する: >
3312                         :call histdel("search", -1)
3313                         :let @/ = histget("search", -1)
3314
3315 histget({history} [, {index}])                          *histget()*
3316                 結果は{history}の第{index}エントリーを表わす文字列。{history}
3317                 の部分に可能な値は|hist-names|を、{index}については
3318                 |:history-indexing|を参照。指定されたエントリが存在しない場合
3319                 は空文字列が返される。{index}が省略された場合には、履歴中の最
3320                 新のエントリが戻り値として使用される。
3321
3322                 例:
3323                 2つ前に行なわれた検索をやり直す: >
3324                         :execute '/' . histget("search", -2)
3325
3326 <               |:history|によって出力される{num}番目のエントリを、再
3327                 度実行するための":H {num}"というコマンドを定義する。 >
3328                         :command -nargs=1 H execute histget("cmd",0+<args>)
3329 <
3330 histnr({history})                                       *histnr()*
3331                 結果は数値で{history}の現在のエントリー数。{history}の部分に可
3332                 能な値は|hist-names|を参照。エラーが起こった場合、-1が返され
3333                 る。
3334
3335                 例: >
3336                         :let inp_index = histnr("expr")
3337 <
3338 hlexists({name})                                        *hlexists()*
3339                 結果は数値で、{name}という名のハイライトグループが存在すれば、
3340                 非ゼロの値が返される。これはなんらかの方法でそのグループが既に
3341                 定義されている時にのみ起こる。これの為に実際に何らかのハイライ
3342                 ティングアイテムが設定されている必要はなく、単に構文アイテムと
3343                 しても使われるだろう。
3344                                                         *highlight_exists()*
3345                 以前の名前: highlight_exists().
3346
3347                                                         *hlID()*
3348 hlID({name})    結果は数値で、{name}という名前のハイライトグループのID番号。そ
3349                 のハイライトグループが存在しない場合は0が返される。
3350                 これはハイライトグループについての情報を獲得するために使用され
3351                 る。例えば"Comment"グループの背景色を取得するにはこのようにす
3352                 る: >
3353         :echo synIDattr(synIDtrans(hlID("Comment")), "bg")
3354 <                                                       *highlightID()*
3355                 以前の名前: highlightID()
3356
3357 hostname()                                              *hostname()*
3358                 結果は文字列で、現在Vimが実行されているマシンの名前。名前が256
3359                 文字を超える場合、超えた部分は切り捨てられる。
3360
3361 iconv({expr}, {from}, {to})                             *iconv()*
3362                 文字列{expr}をエンコーディング{from}からエンコーディング{to}に
3363                 変換した文字列を返す。
3364                 変換が完全に失敗したときは空文字列を返す。一部の文字が変換でき
3365                 なかった場合、その文字は "?" に置き換わる。
3366                 エンコーディング名はライブラリ関数iconv()が受け付けるものなら
3367                 なんでもよい。":!man 3 iconv"を参照。
3368                 ほとんどの変換は、Vimが|+iconv|機能つきでコンパイルされている
3369                 ときのみ利用可能。|+iconv|つきでないときもUTF-8からlatin1への
3370                 変換とその逆は行える。
3371                 オプション'encoding'の値に関係なく、特殊な文字を含むメッセージ
3372                 を表示するために使える。UTF-8でエンコードされたメッセージを表
3373                 示するには次のようにする: >
3374                         echo iconv(utf8_str, "utf-8", &enc)
3375 <               Note Vimは全てのUnicodeエンコーディングに対してUTF-8を使う。
3376                 UCS-2との変換を行おうとしても、自動的にUTF-8との変換に変更され
3377                 る。いずれにせよ、UCS-2はNULバイトを含むため、文字列にUCS-2を
3378                 使うことはできない。
3379                 {+multi_byte機能付きでコンパイルされたときのみ利用可能}
3380
3381                                                         *indent()*
3382 indent({lnum})  カレントバッファの{lnum}行目のインデント量を数値で返す。この
3383                 インデント量はスペース単位で数えられ、'tabstop'の値が関係する。
3384                 {lnum}は|getline()|の場合と同様に扱われる。
3385                 {lnum}が無効なときは-1を返す。
3386
3387
3388 index({list}, {expr} [, {start} [, {ic}]])                      *index()*
3389                 リスト|List| {list}の中で、{expr}に等しい要素の最小のインデッ
3390                 クスを返す。自動的な変換は行われないので、文字列の "4" は数値
3391                 の 4 とは異なると判定される。そして数値の 4 は浮動小数点数の
3392                 4.0 とも異なる。'ignorecase' はここでは適用されず、つねに大文
3393                 字・小文字は区別される。
3394                 {start}が指定された場合はインデックス{start}から要素の検索を始
3395                 める(負数を指定すると末尾からの相対位置となる)。
3396                 {ic}に0でない値が指定された場合、大文字・小文字は区別されない。
3397                 そうでない場合は区別される。
3398                 {list}の中に{expr}が見つからない場合は-1を返す。
3399                 例: >
3400                         :let idx = index(words, "the")
3401                         :if index(numbers, 123) >= 0
3402
3403 input({prompt} [, {text} [, {completion}]])             *input()*
3404                 結果は文字列で、ユーザがコマンドラインに入力したものが返される。
3405                 引数 {prompt} にはプロンプト文字列か空文字列を指定する。空文字
3406                 列の場合はプロンプトなしになる。'\n'を使ってプロンプトに改行を
3407                 含めることができる。|:echohl|によるハイライトの設定がプロン
3408                 プトに適用される。入力はコマンドラインと同様に行え、同じ編集コ
3409                 マンドやキーマップが使用できる。input()に入力された文字列には、
3410                 他の履歴とは独立した履歴が与えられる。
3411                 例: >
3412                         :if input("Coffee or beer? ") == "beer"
3413                         :  echo "Cheers!"
3414                         :endif
3415 <
3416                 省略可能な引数{text}が与えられ、空でないならば、それが入力の初
3417                 期値として、ユーザが入力したのと同じ様に表示される。例: >
3418                         :let color = input("Color? ", "white")
3419
3420 <               省略可能な引数{completion}はこの入力において利用できる補完の種
3421                 類を指定する。この引数がないときは補完は行われない。対応してい
3422                 る補完の種類は、ユーザ定義コマンドにおいて引数"-complete="で指
3423                 定するものと同じである。詳しくは|:command-completion|を参照。
3424                 例: >
3425                         let fname = input("File: ", "", "file")
3426 <
3427                 NOTE: この関数はGUIモードしか持たないバージョン(例、Win32 GUI)
3428                 のVimでは、スタートアップファイルの中で使用することはできな
3429                 い。
3430                 NOTE: マッピングの中からinput()を呼ぶと、そのマッピングの残り
3431                 の文字が消費される。マッピングは、その文字が入力されたときと同
3432                 じように処理されるためである。
3433                 これを避けるには、input()の前に|inputsave()|を呼び、input()の
3434                 後に|inputrestore()|を呼ぶ。もう1つの対策は、|:execute|や
3435                 |:normal|を使うなどして、そのマッピングでそれ以上文字を続けな
3436                 いようにすることである。
3437
3438                 マッピングと同時に使う例: >
3439                         :nmap \x :call GetFoo()<CR>:exe "/" . Foo<CR>
3440                         :function GetFoo()
3441                         :  call inputsave()
3442                         :  let g:Foo = input("enter search pattern: ")
3443                         :  call inputrestore()
3444                         :endfunction
3445
3446 inputdialog({prompt} [, {text} [, {cancelreturn}]])             *inputdialog()*
3447                 |input()|と同様。GUIで動作していて、テキストダイアログがサポー
3448                 トされている場合はダイアログを表示してテキストを入力させる。
3449                 例: >
3450                         :let n = inputdialog("value for shiftwidth", &sw)
3451                         :if n != ""
3452                         :  let &sw = n
3453                         :endif
3454 <               ダイアログがキャンセルされたときは{cancelreturn}を返す。
3455                 {cancelreturn}が省略されているときは空文字列を返す。
3456                 <Enter>を押すとOKボタンを押すのと同じ動作になる。<Esc>を押すと
3457                 キャンセルボタンを押すのと同じ動作になる。
3458                 NOTE: コマンドライン補完は対応していない。
3459
3460 inputlist({textlist})                                   *inputlist()*
3461                 {textlist}は文字列のリスト|List|でなければならない。1行につき
3462                 リストの要素を1個表示し、ユーザに数字を入力するよう促す。入力
3463                 された数字を返す。
3464                 ユーザはマウスで文字列をクリックすることでも選択できる。最初の
3465                 文字列を選択すると0が返る。最初の文字列より上をクリックすると
3466                 負数が返る。プロンプト自身をクリックすると{textlist}の長さ+1が
3467                 返る。
3468                 {textlist}の要素数はオプション'lines'の値より少なくなければな
3469                 らない。そうでないと動作しない。最初の要素にメッセージを書き、
3470                 各文字列の先頭に番号をつけておくとよい。
3471                 例: >
3472                         let color = inputlist(['Select color:', '1. red',
3473                                 \ '2. green', '3. blue'])
3474
3475 inputrestore()                                          *inputrestore()*
3476                 前回の|inputsave()|で保存しておいた先行入力を復元する。
3477                 inputsave()と同じ回数だけ呼ぶようにしなければならない。しかし
3478                 多く呼びすぎても害はない。復元するものがなければ1を、そうでな
3479                 ければ0を返す。
3480
3481 inputsave()                                             *inputsave()*
3482                 先行入力(マッピングにより入力された文字も含む)を保存し、クリア
3483                 することにより、これ以降のプロンプトがユーザからの入力を得るよ
3484                 うにする。プロンプトの後で、対応するinputrestore()を呼び出さね
3485                 ばならない。複数回呼ぶこともできる。ただしその場合は同じ回数だ
3486                 けinputrestore()を呼ばなくてはならない。
3487                 メモリ不足のときは1を、そうでなければ0を返す。
3488
3489 inputsecret({prompt} [, {text}])                        *inputsecret()*
3490                 |input()|とほぼ同じだが、以下の2点が異なる:
3491                 a) ユーザの入力をアスタリスク("*")の列として表示し、入力内容を
3492                 読めないようにする。
3493                 b) ユーザの入力が入力履歴|history|に残らない。
3494                 ユーザの入力内容を文字列として返す。
3495                 NOTE: コマンドライン補完には対応していない。
3496
3497 insert({list}, {item} [, {idx}])                        *insert()*
3498                 リスト|List| {list}の初めに{item}を挿入する。
3499                 {idx}が指定されたときはインデックス{idx}の要素の前に{item}を挿
3500                 入する。{idx}が0のときは{idx}を省略した場合と同じ様に最初の要
3501                 素の前に挿入する。{idx}は負数でもよい(|list-index|参照)。-1を
3502                 指定すると最後の要素の前に挿入する。
3503                 挿入した結果のリストを返す。例: >
3504                         :let mylist = insert([2, 3, 5], 1)
3505                         :call insert(mylist, 4, -1)
3506                         :call insert(mylist, 6, len(mylist))
3507 <               最後の例は|add()|を使うともっと簡単に書ける。
3508                 Note {item}がリストの場合は、1個の要素として追加される。リスト
3509                 を連結するには|extend()|を使うこと。
3510
3511                                                         *isdirectory()*
3512 isdirectory({directory})
3513                 結果は数値で、{directory}という名前のディレクトリが存在すれば
3514                 TRUEとなる。{directory}が存在しないか、存在したとしてもディレ
3515                 クトリではなかった場合には、FALSEが返される。文字列として解釈
3516                 できるのならば{directory}の表現はどのようなものであってもかま
3517                 わない。
3518
3519 islocked({expr})                                        *islocked()* *E786*
3520                 結果は数値で、{expr}がロックされている変数の名前ならば非0を返
3521                 す。
3522                 {expr}は変数の名前、リストの要素、辞書の要素のいずれかでなけれ
3523                 ばならない。変数そのものを指定しないように注意。例: >
3524                         :let alist = [0, ['a', 'b'], 2, 3]
3525                         :lockvar 1 alist
3526                         :echo islocked('alist')         " 1
3527                         :echo islocked('alist[1]')      " 0
3528
3529 <               {expr}が存在しない変数のときはエラーメッセージが表示される。変
3530                 数の存在を確認するには|exist()|を使う。
3531
3532 items({dict})                                           *items()*
3533                 {dict}の全要素のキー・値のペアからなるリストを返す。戻り値の各
3534                 要素はリストであり、キーと値の2個の要素を持つ。戻り値のリスト
3535                 の要素の順序は不定である。
3536
3537
3538 join({list} [, {sep}])                                  *join()*
3539                 リスト{list}の要素を連結し、1個の文字列にして返す。
3540                 {sep}が指定されたときは、要素の間にそれを挿入する。{sep}が指定
3541                 されたときは1個のスペースが使われる。
3542                 Note 末尾には{sep}がつかない。末尾にもつけたければ以下のように
3543                 する: >
3544                         let lines = join(mylist, "\n") . "\n"
3545 <               {list}の要素が文字列なら、そのまま使われる。リストと辞書は
3546                 |string()|を使ったときと同じようにして文字列に変換される。
3547                 この逆を行う関数は|split()|である。
3548
3549 keys({dict})                                            *keys()*
3550                 {dict}の全キーからなるリストを返す。リストの順序は不定である。
3551
3552                                                         *len()* *E701*
3553 len({expr})     結果は数値で、引数{expr}の長さ。{expr}が文字列または数値のとき
3554                 は|strlen()|と同じようにバイト単位での長さを返す。
3555                 {expr}がリストのときは要素数を返す。
3556                 {expr}が辞書のときは要素数を返す。
3557                 それ以外のときはエラーとなる。
3558
3559                                                         *libcall()*
3560 libcall({libname}, {funcname}, {argument})
3561                 ランタイムライブラリ{libname}の関数{funcname}を、引数
3562                 {argument}として呼び出す。
3563                 Vimで使うように特別に作ったライブラリの関数を呼ぶために使われ
3564                 る。引数は1個しか指定できないため、普通のライブラリ関数を呼ぶ
3565                 にはかなり制限がある。
3566                 結果には、呼び出した関数から返された文字列が返される。呼び出し
3567                 た関数がNULLを返した場合には、Vimには空文字列""が戻される。
3568                 関数の戻り値が数値である場合には|libcallnr()|を使うこと。
3569                 もしも引数が数値ならば、関数にはint型の引数が1つ渡される。引数
3570                 が文字列の場合には、関数にはヌル終端記号を持つ文字列が引数とし
3571                 て渡される。
3572                 |restrict-mode|の中で呼ぶと失敗する。
3573
3574                 libcall()によってVimを再コンパイルすることなく'plug-in'と呼ば
3575                 れる独自の拡張を行なうことができるようになる。それは(直接)シス
3576                 テムの関数を呼ぶ、ということではない。システム関数を呼ぶとおそ
3577                 らくVimがクラッシュするだろう。
3578
3579                 Win32では、あなたが書いた関数をDLLに置かなければならず、また通
3580                 常のC呼出し規約を使用しなければならない(WindowsのシステムDLLが
3581                 使うPascalではない)。関数は正確に1つのパラメータ、char型ポイン
3582                 タもしくはint型を取らなければならず、戻り値としてchar型ポイン
3583                 タかNULLを返さなければならない。返されるchar型ポインタは、関数
3584                 終了後も有効なポインタ(例えばDLL内の静的なデータ)を指さなけれ
3585                 ばならない。(malloc等で)割り当てられたメモリを保持していた場
3586                 合、それはリークしてしまう。DLL内のスタティックバッファを用い
3587                 る方法は動くかもしれないが、使用済みDLLがメモリから削除される
3588                 と同時に解放されてしまう。
3589
3590                 警告: もしも関数が有効ではないポインタを返すと、Vimはクラッ
3591                 シュしてしまう。関数が数値を返してしまった場合、Vimはそれをポ
3592                 インタとして扱ってしまうので、やはりクラッシュが起こる。
3593                 Win32のシステムでは、{libname}はDLLのファイル名の拡張子".DLL"
3594                 を付けてはならない。通常の(パスの通った)場所にDLLがない場合に
3595                 は、フルパスで指定する必要がある。
3596                 Unixでは、独自のプラグインをコンパイルするときはオブジェクトコー
3597                 ドを位置独立('PIC')としてコンパイルしなければならない。
3598                 {Win32と、|+libcall|機能が有効になっているUnixでのみ利用可能}
3599                 例: >
3600                         :echo libcall("libc.so", "getenv", "HOME")
3601 <
3602                                                         *libcallnr()*
3603 libcallnr({libname}, {funcname}, {argument})
3604                 |libcall()|とほぼ同様だが、文字列でなくintを返す関数に使う。
3605                 {Win32と、|+libcall|機能が有効になっているUnixでのみ利用可能}
3606                 例: >
3607                         :echo libcallnr("/usr/lib/libc.so", "getpid", "")
3608                         :call libcallnr("libc.so", "printf", "Hello World!\n")
3609                         :call libcallnr("libc.so", "sleep", 10)
3610 <
3611                                                         *line()*
3612 line({expr})    結果は数値で、{expr}で与えられた位置のファイル内での行番号。受
3613                 け付けられる位置指定は次の通り:
3614                     .       カーソルの位置
3615                     $       現在のバッファの最後の位置
3616                     'x      マークxの位置(マークが設定されていない場合、0が返
3617                             る)
3618                     w0      カレントウィンドウの最上行
3619                     w$      カレントウィンドウの最下行
3620                     v       ビジュアルモードでは: ビジュアル選択領域の開始行
3621                             (カーソルがその端)。ビジュアルモード以外ではカーソ
3622                             ル位置を返す。すぐに更新される点が |'<| と違う。
3623                 Note 他のファイルのマークも使える。その場合、戻り値はそのファ
3624                 イルの行番号となる。
3625                 桁番号を取得するには|col()|を使う。両方を取得するには
3626                 |getpos()|を使う。
3627                 例: >
3628                         line(".")               カーソルの行番号
3629                         line("'t")              マークtの位置の行番号
3630                         line("'" . marker)      マークmarkerの位置の行番号
3631 <                                                       *last-position-jump*
3632                 このオートコマンドはファイルを開いた時に、最後に開かれていた時
3633                 の行へ自動的にジャンプするものである。これは'"マークがセットさ
3634                 れている時にのみ有効である: >
3635         :au BufReadPost * if line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g`\"" | endif
3636
3637                                                         *line2byte()*
3638 line2byte({lnum})
3639                 バッファの先頭から、{lnum}行目までのバイト数を返す。これには現
3640                 在のバッファのオプション'fileformat'に従った、end-of-line(行終
3641                 端)文字も含まれている。最初の行においては1が返る。
3642                 次のようにすることで最終行を含むバイトサイズを獲得することがで
3643                 きる: >
3644                         line2byte(line("$") + 1)
3645 <               これはファイルの大きさプラス1になる。
3646                 {lnum}が無効であるか、|+byte_offset|機能がコンパイル時に無効に
3647                 されている場合、-1が返される。
3648                 |byte2line()|、|go|及び|:goto|も参照。
3649
3650 lispindent({lnum})                                      *lispindent()*
3651                 'lisp'をオンにしたときと同じlisp用のインデント規則に従った場合
3652                 の{lnum}行目のインデント量を返す。
3653                 インデント量はスペースで数えられ、'tabstop'の値は関係ない。
3654                 {lnum}は|getline()|の場合と同様に扱われる。
3655                 {lnum}が無効な値のときや|+lispindent|機能なしでコンパイルされ
3656                 ているときは-1を返す。
3657
3658                                                         *localtime()*
3659 localtime()
3660                 現在の時刻、1970年1月1日からの経過秒数を返す。|strftime()|と
3661                 |getftime()|も参照。
3662
3663 log10({expr})                                           *log10()*
3664                 浮動小数点数 {expr} の 10 を底とする対数を |Float| で返す。
3665                 {expr} は |Float| または |Number| に評価されなければならな
3666                 い。
3667                 例: >
3668                         :echo log10(1000)
3669 <                       3.0 >
3670                         :echo log10(0.01)
3671 <                       -2.0
3672                 {|+float| 機能つきでコンパイルされたときのみ有効}
3673
3674 map({expr}, {string})                                   *map()*
3675                 {expr}はリスト|List|または辞書|Dictionary|。
3676                 {expr}の各要素を、{string}を評価した結果で置き換える。
3677                 {string}の中では|v:val|が現在の要素の値を保持している。
3678                 辞書の場合は|v:key|が現在の要素のキーを保持している。
3679                 リストの場合は|v:key|が現在の要素のインデックスを保持してい
3680                 る。
3681                 例: >
3682                         :call map(mylist, '"> " . v:val . " <"')
3683 <               これは"mylist"の各要素の前に"> "をつけ、後に" <"をつける。
3684
3685                 Note {string}は式を表す文字列である。バックスラッシュを二重に
3686                 しなくても済むように|literal-string|を使うとよいだろう。ただし
3687                 その場合はシングルクォートを2重にしなければならない。
3688
3689                 この操作はその場で(in-place)行われる。リストや辞書を変更したく
3690                 ない場合は最初にコピーを作ること: >
3691                         :let tlist = map(copy(mylist), ' & . "\t"')
3692
3693 <               式を適用した結果の{expr}を返す。{string}を評価している最中にエ
3694                 ラーが発生した場合は、それ以降の要素は処理されない。
3695
3696
3697 maparg({name}[, {mode} [, {abbr}]])                     *maparg()*
3698                 モード{mode}におけるキーマップ{name}のrhsを返す。{name}という
3699                 キーマップが存在しない場合、空文字列が返される。{mode}には次の
3700                 文字が使用可能:
3701                         "n"     ノーマル
3702                         "v"     ビジュアル
3703                         "o"     オペレータ待機 (Operator-pending)
3704                         "i"     インサート
3705                         "c"     コマンドライン
3706                         "l"     langmap |language-mapping|
3707                         ""      ノーマル、ビジュアル、及びオペレータ待機
3708                 {mode}が省略された場合、""が使用される。
3709                 {abbr}が指定され、0でない場合はマッピングでなく短縮入力を対象
3710                 とする。
3711                 {name}には":map"コマンドで使用可能な、特殊なキー名が指定でき
3712                 る。結果の文字列内の特殊文字は、":map"コマンドでリスト表示した
3713                 時のように変換される。
3714                 まずカレントバッファにローカルなマッピングを探し、次のグローバ
3715                 ルマッピングを探す。
3716                 この関数を使うと、あるキーに対して既にマップがされているとき、
3717                 その動作を行いつつ、再マップすることができる。概要: >
3718                         exe 'nnoremap <Tab> ==' . maparg('<Tab>', 'n')
3719
3720 mapcheck({name}[, {mode} [, {abbr}]])                   *mapcheck()*
3721                 モード{mode}におけるキーマップ{name}が存在するかチェックする。
3722                 {name}に指定できる特殊文字は|maparg()|を参照。
3723                 {abbr}が指定され、0でない場合はマッピングでなく短縮入力を対象
3724                 とする。
3725                 マッピングが{name}で始まるとき、またはマッピングが{name}のはじ
3726                 めに等しいときマッチすると見なされる。
3727
3728                         マッチするか    "a"     "ab"    "abc" ~
3729                    mapcheck("a")        yes     yes      yes
3730                    mapcheck("abc")      yes     yes      yes
3731                    mapcheck("ax")       yes     no       no
3732                    mapcheck("b")        no      no       no
3733
3734                 maparg()との違いは、mapcheck()は{name}にマッチするマップを見つ
3735                 けるが、maparg()はぴったり{name}に一致するマッピングのみを見つ
3736                 ける。
3737                 {name}にマッチするキーマップが存在しない時には、空文字列が返さ
3738                 れる。結果が一つならばマップされたrhsが返される。複数見つかっ
3739                 た場合には、それらのうちどれか一つのrhsが返される。
3740                 まずカレントバッファにローカルなマッピングを探し、次のグローバ
3741                 ルマッピングを探す。
3742                 この関数はマッピングが曖昧にならないかチェックするために使うこ
3743                 とができる。例: >
3744         :if mapcheck("_vv") == ""
3745         :   map _vv :set guifont=7x13<CR>
3746         :endif
3747 <               これは、"_vv"というマッピングが"_v"とか"_vvv"といったマッピン
3748                 グと衝突しないように事前にチェックしている。
3749
3750 match({expr}, {pat}[, {start}[, {count}]])                      *match()*
3751                 {expr}がリストの場合は、{pat}にマッチする最初の要素のインデッ
3752                 クスを返す。各要素は文字列として扱われる。リストと辞書はechoし
3753                 たときと同じように文字列表現に変換される。
3754                 それ以外の場合は、{expr}は文字列として扱われる。{expr}の中で
3755                 {pat}にマッチするインデックス(バイト単位のオフセット)を表す数
3756                 値を返す。
3757                 最初の文字またはリストの最初の要素にマッチしたときは0を返す。
3758                 マッチがないときは-1を返す。
3759                 例: >
3760                         :echo match("testing", "ing")   " 結果は 4
3761                         :echo match([1, 'x'], '\a')     " 結果は 1
3762 <               {pat}の扱われ方については|string-match|を参照。
3763                                                                 *strpbrk()*
3764                 strpbrk()に相当する関数はVimに存在しない。しかし同じことを次の
3765                 ようにしてできる: >
3766                         :let sepidx = match(line, '[.,;: \t]')
3767 <                                                               *strcasestr()*
3768                 strcasestr()に相当する関数はVimに存在しない。しかし正規表現に
3769                 "\c"をつければ大文字・小文字の違いを無視できる: >
3770                         :let idx = match(haystack, '\cneedle')
3771 <
3772                 {start}が指定されたときは、文字列のバイトインデックス{start}の
3773                 位置、またはリストの{start}の要素から検索を始める。
3774                 その場合も戻り値は最初の文字/要素から数えたインデックスである
3775                 ことに注意。例: >
3776                         :echo match("testing", "ing", 2)
3777 <               の結果は"4"。 >
3778                         :echo match("testing", "ing", 4)
3779 <               の結果は"4"。 >
3780                         :echo match("testing", "t", 2)
3781 <               の結果は"3"。
3782                 文字列の場合、{start} > 0のときは、その文字列が{start}バイト後
3783                 から始まるかのように扱われる。そのため、"^"は{start}の位置にマッ
3784                 チする。ただし{count}が指定されたときは、{start}より前における
3785                 マッチを無視しているかのように振る舞う(これは後方互換性を保つ
3786                 のを少々複雑にしている)。
3787                 文字列の場合、{start} < 0のときは{start}に0をセットする。リス
3788                 トの場合は、末尾からインデックスを数えるという意味になる。
3789                 {start}が範囲外の場合(文字列で{start} > strlen({expr})となった
3790                 場合、リストで{start} > len({expr})となった場合)は-1を返す。
3791
3792                 {count}が指定されたときは{count}番目のマッチ位置を返す。文字列
3793                 でマッチが見つかったとき、次のマッチングは1文字先から行われる。
3794                 よって次の例は1を返す: >
3795                         echo match("testing", "..", 0, 2)
3796 <               リストの場合は次の要素から検索を続ける。
3797                 Note {count}を指定すると、{start}の扱い方が変わってしまう。
3798                 前の段落を参照。
3799
3800                 受け付ける正規表現については|pattern|を参照。
3801                 オプション'ignorecase'により、大文字・小文字を区別するかどうか
3802                 を設定できる。'smartcase'は適用されない。マッチングは常に
3803                 'magic'をオン、'cpoptions'を空にした状態で行われる。
3804
3805                                         *matchadd()* *E798* *E799* *E801*
3806 matchadd({group}, {pattern}[, {priority}[, {id}]])
3807                 カレントウィンドウで強調表示するパターンを定義する。このパター
3808                 ンのことを「マッチ」と呼ぶ。構文グループ {group}で強調する。戻
3809                 り値は、マッチを識別する ID である。|matchdelete()|でこの ID
3810                 を指定してマッチを削除することができる。
3811
3812                 省略可能な引数 {priority} はマッチの優先度を指定する。優先度が
3813                 高いマッチは、より低いマッチの強調を上書きする。優先度は整数で
3814                 指定する(負の数も可能)。{priority} が指定されない場合は既定の
3815                 優先度 10 となる。'hlsearch' の優先度はゼロで、したがってゼロ
3816                 より大きい優先度のマッチはすべてそれを上書きする。構文ハイライ
3817                 ト('syntax' を参照)は独立したメカニズムであり、優先度がいくつ
3818                 であろうとマッチは構文ハイライトより優先する。
3819
3820                 {id} は特定のマッチ ID を返すことを要求する。指定された ID が
3821                 すでに使われていたら、エラーメッセージが表示され、そのマッチは
3822                 登録されない。ID は正の整数を指定する(ゼロは除く)。ID 1, 2, 3
3823                 は |:match|, |:2match|, |:3match| 用に予約されている。{id} が
3824                 指定されないときは、|matchadd()| が自動的に空いている ID を取
3825                 得する。
3826
3827                 コマンド |:match| と異なり、マッチの個数に上限はない。
3828
3829                 例: >
3830                         :highlight MyGroup ctermbg=green guibg=green
3831                         :let m = matchadd("MyGroup", "TODO")
3832 <               このパターンを削除するには: >
3833                         :call matchdelete(m)
3834
3835 <               |matchadd()| と |:match| で定義したマッチのリストは
3836                 |getmatches()| で取得できる。全てのマッチを削除するのは
3837                 |clearmatches()| 一発でできる。
3838
3839 matcharg({nr})                                                  *matcharg()*
3840                 |:match|、|:2match|、|:3match|によって設定されているマッチパター
3841                 ンの情報を返す。{nr}が1のときは|:match|の情報、2のときは
3842                 |:2match|の情報、3のときは|:3match|の情報を返す。
3843                 戻り値は次の2個の要素を持つリストである:
3844                         引数で指定したハイライトグループ名
3845                         引数で指定した検索パターン
3846                 {nr}が1、2、3のどれでもないときは空リストを返す。
3847                 マッチパターンがセットされていないときは['', '']を返す。
3848                 |:match|を保存し、復元するのに便利である。
3849                 |:match| を使った強調は 3 個までに限られている。
3850                 |matchadd()| にはこの制限はない。
3851
3852 matchdelete({id})                              *matchdelete()* *E802* *E803*
3853                 |matchadd()| または |:match| で定義したマッチの中で ID が {id}
3854                 であるものを削除する。成功したときは 0、失敗したときは
3855                 -1 を返す。|matchadd()| の例を参照。すべてのマッチを削除するの
3856                 は |clearmatches()| 一発でできる。
3857
3858 matchend({expr}, {pat}[, {start}[, {count}]])                   *matchend()*
3859                 |match()|と同じだが、返されるのはマッチした部分文字列の終了後の
3860                 インデックスである。例: >
3861                         :echo matchend("testing", "ing")
3862 <               結果は"7"。
3863                                                         *strspn()* *strcspn()*
3864                 Vimにはstrspn()やstrcspn()に相当する関数はないが、matchend()を
3865                 使えば同じことができる: >
3866                         :let span = matchend(line, '[a-zA-Z]')
3867                         :let span = matchend(line, '[^a-zA-Z]')
3868 <               ただしマッチがないときには-1を返すところが異なる。
3869
3870                 {start}は|match()|の場合と同じ意味を持つ。 >
3871                         :echo matchend("testing", "ing", 2)
3872 <               結果は"7"。 >
3873                         :echo matchend("testing", "ing", 5)
3874 <               結果は"-1"。
3875                 {expr}がリストの場合、戻り値は |match()| と等しくなる。
3876
3877 matchlist({expr}, {pat}[, {start}[, {count}]])                  *matchlist()*
3878                 |match()| と同じだがリストを返す。リストの最初の要素は、
3879                 matchstr()が返すのと同じマッチした文字列。それ以降の要素は
3880                 |:substitute|における"\1"、"\2"のようなサブマッチである。\1か
3881                 ら\9までの間で、指定されなかったものは空文字列となる。例: >
3882                         echo matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)')
3883 <               結果は['acd', 'a', '', 'c', 'd', '', '', '', '', '']となる。
3884                 マッチしなかったときは空リストを返す。
3885
3886 matchstr({expr}, {pat}[, {start}[, {count}]])                   *matchstr()*
3887                 |match()| と同じだが、マッチした文字列を返す。例: >
3888                         :echo matchstr("testing", "ing")
3889 <               結果は"ing"。
3890                 マッチしなかったときは""を返す。
3891                 {start}の意味は |match()| の場合と同じ。 >
3892                         :echo matchstr("testing", "ing", 2)
3893 <               結果は"ing"。 >
3894                         :echo matchstr("testing", "ing", 5)
3895 <               結果は""。
3896                 {expr}がリストのときはマッチした要素を返す。
3897                 その要素の型は変換されないため、必ずしも文字列であるとは限らな
3898                 い。
3899
3900                                                         *max()*
3901 max({list})     {list}の全要素の値の最大値を返す。
3902                 {list}がリストでなかったり、要素のどれかが数値に変換できない場
3903                 合はエラーとなる。
3904                 空リストの場合は0を返す。
3905
3906                                                         *min()*
3907 min({list})     {list}の全要素の値の最小値を返す。
3908                 {list}がリストでなかったり、要素のどれかが数値に変換できない場
3909                 合はエラーとなる。
3910                 空リストの場合は0を返す。
3911
3912                                                         *mkdir()* *E739*
3913 mkdir({name} [, {path} [, {prot}]])
3914                 ディレクトリ{name}を作成する。
3915                 {path}が"p"のときは必要に応じて途中のディレクトリも作成される。
3916                 そうでないときは""にすること。
3917                 {prot}は作成するディレクトリの保護ビット。デフォルトは0755
3918                 (rwxr-xr-x: 所有者は読み書き可能、他の人は読み込み可能)。
3919                 他の人が読み込めないようにするには0700とすること。{prot} は
3920                 {name} の最後の部分にのみ適用される。なので、/tmp/foo/bar
3921                 を作成すると /tmp/foo は 0755 で作成される。
3922                 例: >
3923                         :call mkdir($HOME . "/tmp/foo/bar", "p", 0700)
3924 <               |sandbox|の中ではこの関数は使用できない。
3925                 システムによっては利用できない場合がある。これを確認するには次
3926                 のようにする: >
3927                         :if exists("*mkdir")
3928 <
3929                                                         *mode()*
3930 mode([expr])            現在のモードを示す文字列を返す。
3931                         [expr] に 0 でない数値か空でない文字列(|non-zero-arg|)
3932                         を指定した場合、フルモードが返される。それ以外の場合は
3933                         最初の一文字だけが返される。" " と "0"はどちらも空文字
3934                         列ではないことに注意。
3935
3936                         n       ノーマル
3937                         no      オペレータ待機
3938                         v       文字指向ビジュアル
3939                         V       行指向ビジュアル
3940                         CTRL-V  矩形指向ビジュアル
3941                         s       文字指向セレクト
3942                         S       行指向セレクト
3943                         CTRL-S  矩形指向セレクト
3944                         i       インサート
3945                         R       置換 |R|
3946                         Rv      仮想置換 |gR|
3947                         c       コマンドライン
3948                         cv      Vim Ex モード |gQ|
3949                         ce      ノーマル Ex モード |Q|
3950                         r       Hit-enter プロンプト
3951                         rm      -- more -- プロンプト
3952                         r?      ある種の |:confirm| 問い合わせ
3953                         !       シェルまたは外部コマンド実行中
3954                 これらはオプション'statusline'の中や、|remote_expr()| といっし
3955                 ょに使うと便利である。他のほとんどの場所では"c"または"n"しか返
3956                 さない。
3957                 |visualmode()| も参照。
3958
3959 nextnonblank({lnum})                                    *nextnonblank()*
3960                 {lnum}行以降({lnum}行を含む)の最初の非空行の行番号を返す。
3961                 例: >
3962                         if getline(nextnonblank(1)) =~ "Java"
3963 <               {lnum}が無効なときや、それ以降に非空行がないときは0を返す。
3964                 |prevnonblank()|も参照。
3965
3966                                                         *nr2char()*
3967 nr2char({expr})
3968                 コード{expr}で表される1文字からなる文字列を返す。例: >
3969                         nr2char(64)             "@"を返す
3970                         nr2char(32)             " "を返す
3971 <               現在の'encoding'が適用される。"utf-8"の場合の例: >
3972                         nr2char(300)            短音記号つきのIを返す
3973 <               Note Vim内部では、ファイル中のNUL文字を改行文字(0x0A)に変換し
3974                 て保持している。そのため、nr2char(10)とすればNUL文字を指定でき
3975                 る。nr2char(0)は真のNUL文字(文字列の終端)となるので、空文字列
3976                 を返す。
3977
3978                                                         *getpid()*
3979 getpid()        Vim のプロセス ID を数値で返す。Unix と MS-Windows では Vim が
3980                 終了するまでこれは一意な数値である。MS-DOS では常にゼロである。
3981
3982                                                         *getpos()*
3983 getpos({expr})  {expr}の位置を返す。{expr}として指定できる値については
3984                 |line()|を参照。
3985                 結果は次の4個の要素を持つリスト|List|:
3986                     [bufnum, lnum, col, off]
3987                 "bufnum"は、'0や'Aのようなマークが指定されたときは、そのマーク
3988                 のバッファ番号となる。それ以外では0となる。
3989                 "lnum"と"col"はバッファ中の位置。桁番号は1から始まる。
3990                 "off"の値は、'virtualedit'がオフのときは常に0で、オンのときは
3991                 その文字の始点からの画面上の桁のオフセットである。つまり、カー
3992                 ソルが<Tab>の中や、その行の最後の文字より後にあるとき意味を持
3993                 つ。
3994                 この関数はカーソル位置を保存し、復元するために使われる: >
3995                         let save_cursor = getpos(".")
3996                         MoveTheCursorAround
3997                         call setpos('.', save_cursor)
3998 <               |setpos()|も参照。
3999
4000 pathshorten({expr})                                     *pathshorten()*
4001                 パス{expr}におけるディレクトリ名を短縮して返す。拡張子、ファイ
4002                 ル名はそのまま保たれる。パスのその他の構成要素は1文字に縮めら
4003                 れる。1文字目の'~'と'.'はそのまま保たれる。例: >
4004                         :echo pathshorten('~/.vim/autoload/myfile.vim')
4005 <                       ~/.v/a/myfile.vim ~
4006                 パスが実際に存在するかどうかは関係ない。
4007
4008 pow({x}, {y})                                           *pow()*
4009                 {x} の {y} 乗を |Float| で返す。{x} と {y} は |Float| または
4010                 |Number| に評価されなければならない。
4011                 例: >
4012                         :echo pow(3, 3)
4013 <                       27.0 >
4014                         :echo pow(2, 16)
4015 <                       65536.0 >
4016                         :echo pow(32, 0.20)
4017 <                       2.0
4018                 {|+float| 機能つきでコンパイルされたときのみ有効}
4019
4020 prevnonblank({lnum})                                    *prevnonblank()*
4021                 {lnum}行以前({lnum}行を含む)の最初の非空行の行番号を返す。
4022                 例: >
4023                         let ind = indent(prevnonblank(v:lnum - 1))
4024 <               {lnum}が無効なときや、それ以降に非空行がないときは0を返す。
4025                 |nextnonblank()|も参照。
4026
4027
4028 printf({fmt}, {expr1} ...)                              *printf()*
4029                 {fmt}にしたがって組み立てた文字列を返す。{fmt}中の"%"変換指示
4030                 子は、対応する引数の値で置き換えられる。例: >
4031                         printf("%4d: E%d %.30s", lnum, errno, msg)
4032 <               結果は次のような形になる:
4033                         "  99: E42 asdfasdfasdfasdfasdfasdfasdfas" ~
4034
4035                 よく使われる変換指示子は次の通り:
4036                   %s    文字列
4037                   %6s   6バイトで右揃えした文字列
4038                   %.9s  9バイトに切り詰めた文字列
4039                   %c    1バイト
4040                   %d    10進数値
4041                   %5d   スペースで埋めて5文字にした10進数値
4042                   %x    16進数値
4043                   %04x  0で埋めて少なくとも4文字にした16進数値
4044                   %X    16進数値(大文字)
4045                   %o    8進数値
4046                   %f    123.456 形式の浮動小数点数
4047                   %e    1.234e3 形式の浮動小数点数
4048                   %E    1.234E3 形式の浮動小数点数
4049                   %g    浮動小数点数。値によって %f または %e となる
4050                   %G    浮動小数点数。値によって %f または %E となる
4051                   %%    文字 % そのもの
4052
4053                 変換子指示は'%'で始まり、変換文字で終わる。それ以外の全ての文
4054                 字はそのままになる。
4055
4056                 "%"は変換指示子の開始を意味する。以下の順序で引数を指定できる:
4057
4058                         %  [flags]  [field-width]  [.precision]  type
4059
4060                 フラグ
4061                         0個以上の以下のフラグを指定できる
4062
4063                     #         値を「代替形式」に変換する。変換指示子c, d, sに
4064                               対してはこのオプションは効果を持たない。変換指示
4065                               子oに対しては数値の精度を上げ、出力文字列の最初
4066                               の文字が0になる。(明示的な精度0で値0が表示される
4067                               ときを除く)
4068                               変換指示子xとXに対しては、値が0でない場合、文字
4069                               列"0x" (変換子Xの場合は"0X")を前につける。
4070
4071                     0 (zero)  ゼロパディングする。全ての変換に対し、変換差され
4072                               た値の左側を空白でなく0で埋める。数値変換(d, o,
4073                               x, X)に対して精度が指定されている場合はフラグ0は
4074                               無視される。
4075
4076                     -         負のフィールド幅を示す。変換値がフィールド境界に
4077                               左揃えされる。変換値の左に空白や0がつくのではな
4078                               く、変換値の右に空白がつく。
4079                               -と0を両方指定した場合は-が有効になる。
4080
4081                     ' ' (space)  空白。符号付き変換(d)で作成される正の数値の前
4082                               に空白が残る。
4083
4084                     +         +文字。符号付き変換で作成される数値の前に常に符
4085                               号を付ける。+と' '(space)を両方していした場合は
4086                               +が有効になる。
4087
4088                 フィールド幅
4089                         10進数文字列(省略可)。最低フィールド幅を指定する。変換
4090                         値のバイト数がこのフィールド幅より少ない場合、左に空白
4091                         がついて(左揃えフラグを指定した場合は右に空白がついて)
4092                         フィールドの幅に合わせられる。
4093
4094                 .精度
4095                         ピリオド'.'の次に数字文字列がつづく形式の精度(省略可)。
4096                         数字文字列を省略した場合、精度は0になる。d, o, x, X変
4097                         換における最低桁数を指定する。また、s変換における最大
4098                         バイト数を指定する。
4099                         浮動小数点数の場合は小数点以下の桁数。
4100
4101                 型
4102                         変換の型を指定する1文字。下記を参照。
4103
4104                 フィールド幅と精度には、数字文字列の代わりにアスタリスク'*'を
4105                 指定できる。その場合、対応する数値の引数がフィールド幅または精
4106                 度となる。負のフィールド幅を指定すると、絶対値がフィールド幅
4107                 となり、左揃えフラグがオンになる。負の精度を指定すると、完全に
4108                 無視される。例: >
4109                         :echo printf("%d: %.*s", nr, width, line)
4110 <               この例は、テキスト"line"の長さを"width"バイトに制限する。
4111
4112                 変換指示子の意味は以下の通り:
4113
4114                                 *printf-d* *printf-o* *printf-x* *printf-X*
4115                 doxX    数値の引数を符号付き10進数(d)、符号なし8進数(o)、符号
4116                         なし16進数(xまたはX)の書式に変換する。xの場合は
4117                         "abcdef"と小文字を使い、Xのの場合は"ABCDEF"と大文字を
4118                         精度は出力する最小桁数を意味する。変換された値を出力
4119                         するのにそれ以下しか必要としない場合は、左側にゼロを
4120                         加えて埋める。
4121                         フィールド幅が存在しない場合や小さすぎる場合でも、数値
4122                         の幅を切り詰めることは決してない。変換結果がフィールド
4123                         幅より多くの桁を必要とする場合は、十分な幅に広げられる。
4124
4125                                                         *printf-c*
4126                 c       引数の数値を1バイトに変換し、結果の文字列を書き出す。
4127
4128                                                         *printf-s*
4129                 s       引数の文字列を出力する。精度を指定した場合、その数値以
4130                         下のバイト数のみを書き出す。
4131
4132                                                         *printf-f* *E807*
4133                 f       Float の引数を 123.456 の形式の文字列に変換する。精度
4134                         は小数点以下の桁数を指定する。精度が 0 のときは小数点
4135                         以下は省略される。精度を指定しないときは 6 桁となる。
4136                         とてつもなく大きい数(範囲外またはゼロによる除算)のとき
4137                         は "inf" となる。"0.0 / 0.0" は "nan" になる。
4138                         例: >
4139                                 echo printf("%.2f", 12.115)
4140 <                               12.12
4141                         丸めはシステムのライブラリに依存する。心配なときは
4142                         |round()| を使うこと。
4143
4144                                                         *printf-e* *printf-E*
4145                 e E     Float の引数を 1.234e+03 という形式('E' のときは
4146                         1.234E+03)の文字列に変換する。精度は 'f' の場合と同じ
4147                         く小数点以下の桁数を指定する。
4148
4149                                                         *printf-g* *printf-G*
4150                 g G     0.001(を含む)から10000000.0(を除く)の間の場合は 'f' の
4151                         形式で変換し、この間にない場合は 'g' は'e'、'G' は 'E'
4152                         の形式によって変換する。精度が指定されないときは余分な
4153                         ゼロ(小数点の直後のゼロ以外)と '+' 記号は省かれる。よっ
4154                         て 10000000.0 は 1.0e7 になる。
4155
4156                                                         *printf-%*
4157                 %       単一の'%'を書き出す。引数は変換しない。完全な変換指定
4158                         は"%%"となる。
4159
4160                 数値の引数を受け取る変換指示子には文字列を与えることもできる。
4161                 変換は自動的に行われる。
4162                 浮動小数点数または文字列の引数を受け取る変換指示子には、数値を
4163                 与えることもできる。変換は自動的に行われる。
4164                 それ以外の型の引数を与えるとエラーメッセージが表示される。
4165
4166                                                         *E766* *E767*
4167                 {expr1}以降の引数の数と"%"変換指示子の個数がちょうど一致しなけ
4168                 ればならない。そうでない場合はエラーとなる。引数は最大18個まで
4169                 使える。
4170
4171
4172 pumvisible()                                            *pumvisible()*
4173                 ポップアップメニューが表示されているときには非0を返す。表示さ
4174                 れていないときは0を返す。|ins-completion-menu|を参照。
4175                 ポップアップメニューを消してしまうような操作を避けるために使わ
4176                 れる。
4177
4178                                                         *E726* *E727*
4179 range({expr} [, {max} [, {stride}]])                            *range()*
4180                 以下のような数値のリスト|List|を返す。
4181                 - {expr}のみを指定したときは:  [0, 1, ..., {expr} - 1]
4182                 - {max}を指定したときは: [{expr}, {expr} + 1, ..., {max}]
4183                 - {string}を指定したときは: [{expr}, {expr} + {stride}, ...,
4184                   {max}] ({max}を超えないように{expr}を{stride}ずつ増加させる)
4185                 最大値が開始位置より1だけ前のときは空リストを返す。最大値が開
4186                 始位置より1以上前のときはエラーになる。
4187                 例: >
4188                         range(4)                " [0, 1, 2, 3]
4189                         range(2, 4)             " [2, 3, 4]
4190                         range(2, 9, 3)          " [2, 5, 8]
4191                         range(2, -2, -1)        " [2, 1, 0, -1, -2]
4192                         range(0)                " []
4193                         range(2, 0)             " エラー!
4194 <
4195                                                         *readfile()*
4196 readfile({fname} [, {binary} [, {max}]])
4197                 ファイル{fname}を読み込み、各行を要素とするリスト|List|を返す。
4198                 行はNL文字で終わるものとする。改行文字がCRであるMacintoshのファ
4199                 イルは単一の長い行となる(どこかにNLが現れない限り)。
4200                 {binary}が"b"に等しい場合、次のようにバイナリモードになる:
4201                 - 最後の行がNLで終わるときは、リストの末尾に余分な空文字列が追
4202                   加される。
4203                 - CR文字を除去しない。
4204                 バイナリモードでない場合:
4205                 - NLの前に現れるCR文字を除去する。
4206                 - 最後の行がNLで終わるかどうかは関係ない。
4207                 NUL文字はすべてNL文字に置換される。
4208                 {max}を指定すると、読み込む行数の最大値となる。ファイルの最初
4209                 の10行をチェックするときに役に立つ: >
4210                         :for line in readfile(fname, '', 10)
4211                         :  if line =~ 'Date' | echo line | endif
4212                         :endfor
4213 <               {max}が負の場合は、ファイルの最後から-{max}行を読み込んで返す。
4214                 ファイルが{max}行以下の場合は全行を返す。
4215                 {max}が0の場合は空リストを返す。
4216                 Note {max}を指定しない場合はファイル全体をメモリに読み込む。エ
4217                 ンコーディング判定も行わないことに注意。必要ならバッファに読み
4218                 込むこと。
4219                 ファイルを開けないときはエラーメッセージを表示し、空リストを返
4220                 す。
4221                 |writefile()|も参照。
4222
4223 reltime([{start} [, {end}]])                            *reltime()*
4224                 時刻値を表す値を返す。値の形式はシステムに依存する。この値を
4225                 |reltimestr()|に渡すと文字列に変換できる。
4226                 引数を指定しないと現在時刻を返す。
4227                 1個の引数を指定すると、その引数で指定された時刻からの経過時間
4228                 を返す。
4229                 2個の引数を指定すると、{start}と{end}の間の経過時間を返す。
4230                 {start}と{end}はreltime()で返される値でなければならない。
4231                 {+reltime機能付きでコンパイルされたときのみ利用可能}
4232
4233 reltimestr({time})                              *reltimestr()*
4234                 時刻値{time}を表現する文字列を返す。秒、ドット、マイクロ秒とい
4235                 う形式になる。例: >
4236                         let start = reltime()
4237                         call MyFunction()
4238                         echo reltimestr(reltime(start))
4239 <               Note このコマンドにかかるオーバーヘッドがこの時間に加算される。
4240                 精度はシステムに依存する。
4241                 文字列をきれいに揃えるために、先頭にスペースが挿入される。この
4242                 スペースを取り除くにはsplit()を使えばよい。 >
4243                         echo split(reltimestr(reltime(start)))[0]
4244 <               |profiling|も参照。
4245                 {+reltime機能付きでコンパイルされたときのみ利用可能}
4246
4247                                                         *remote_expr()* *E449*
4248 remote_expr({server}, {string} [, {idvar}])
4249                 {string}を{server}に送信する。{string}は式と見なされ、評価した
4250                 結果が返ってくる。
4251                 戻り値は文字列かリスト|List|でなければならない。リストの場合は
4252                 要素を連結して文字列に変換される。要素間の区切りは改行文字とな
4253                 る(join(expr, "\n")と同様)。
4254                 {idvar}には変数名を指定する。後でremote_read()で使われる
4255                 {serverid}がその変数に保存される。
4256                 |clientserver|と|RemoteReply|も参照。
4257                 |sandbox|の中ではこの関数は利用できない。
4258                 {|+clientserver|機能付きでコンパイルされたときのみ利用可能}
4259                 Note: なんらかのエラーが発生した場合は、ローカルでエラーメッセー
4260                 ジが表示され、戻り値は空文字列となる。
4261                 例: >
4262                         :echo remote_expr("gvim", "2+2")
4263                         :echo remote_expr("gvim1", "b:current_syntax")
4264 <
4265
4266 remote_foreground({server})                             *remote_foreground()*
4267                 サーバ名{server}のVimをフォアグラウンドに移動させる。
4268                 次を実行するのと同様である: >
4269                         remote_expr({server}, "foreground()")
4270 <
4271                 ただし、次の点が異なる: Win32では、OSが必ずしもサーバが自分自
4272                 身をフォアグラウンドにすることを許可しないので、対応策としてク
4273                 ライアントが仕事を行う。
4274                 Note: foreground()と違い、最小化されていたウィンドウを復元しな
4275                 い。
4276                 |sandbox|の中ではこの関数は利用できない。
4277                 {Win32, Athena, Motif, GTKのGUI版とWin32コンソール版でのみ利用
4278                 可能}
4279
4280
4281 remote_peek({serverid} [, {retvar}])            *remote_peek()*
4282                 {serverid}から文字列を取得可能ならば正の数値を返す。変数
4283                 {retvar}に返信文字列をコピーする。{retvar}は変数の名前を示す文
4284                 字列でなければならない。
4285                 取得できないならば0を返す。
4286                 なんらかの異状のときは-1を返す。
4287                 |clientserver|も参照。
4288                 |sandbox|の中ではこの関数は利用できない。
4289                 {|+clientserver|機能付きでコンパイルされたときのみ利用可能}
4290                 例: >
4291                         :let repl = ""
4292                         :echo "PEEK: ".remote_peek(id, "repl").": ".repl
4293
4294 remote_read({serverid})                         *remote_read()*
4295                 {serverid}からの返信の中で最も古いものを取り出して返す。取り出
4296                 した返信はキューから取り除かれる。キューに返信が入っていないと
4297                 きは、返信を取り出せるようになるまで待機する。
4298                 |clientserver|も参照。
4299                 |sandbox|の中ではこの関数は利用できない。
4300                 {|+clientserver|機能付きでコンパイルされたときのみ利用可能}
4301                 例: >
4302                         :echo remote_read(id)
4303 <
4304                                                         *remote_send()* *E241*
4305 remote_send({server}, {string} [, {idvar}])
4306                 {string}を{server}に送信する。{string}はキー入力として解釈され、
4307                 この関数の呼び出しは即座に戻ってくる。Vimサーバにおいて、受け
4308                 取ったキー入力はマッピング展開されない。|:map|
4309                 {idvar}には変数名を指定する。後でremote_read()で使われる
4310                 {serverid}がその変数に保存される。
4311                 |clientserver|と|RemoteReply|も参照。
4312                 |sandbox|の中ではこの関数は利用できない。
4313                 {|+clientserver|機能付きでコンパイルされたときのみ利用可能}
4314                 Note: なんらかのエラーが発生すると、サーバ側で報告され、表示が
4315                 乱れてしまうかもしれない。
4316                 例: >
4317                 :echo remote_send("gvim", ":DropAndReply ".file, "serverid").
4318                  \ remote_read(serverid)
4319
4320                 :autocmd NONE RemoteReply *
4321                  \ echo remote_read(expand("<amatch>"))
4322                 :echo remote_send("gvim", ":sleep 10 | echo ".
4323                  \ 'server2client(expand("<client>"), "HELLO")<CR>')
4324 <
4325 remove({list}, {idx} [, {end}])                         *remove()*
4326                 {end}を指定しなかった場合: リスト{list}から{idx}位置の要素を削
4327                 除し、その要素を返す。
4328                 {end}を指定した場合: {idx}から{end}まで(両端を含む)の要素を削
4329                 除し、それらの要素からなるリストを返す。{idx}と{end}が同じ要素
4330                 を指す場合、1個の要素からなるリストが返る。{end}が{idx}より前
4331                 になる場合、エラーとなる。
4332                 {idx}と{end}として指定できる値については|list-index|を参照。
4333                 例: >
4334                         :echo "last item: " . remove(mylist, -1)
4335                         :call remove(mylist, 0, 9)
4336 remove({dict}, {key})
4337                 {dict}からキー{key}を持つ要素を削除する。例: >
4338                         :echo "removed " . remove(dict, "one")
4339 <               {dict}に{key}がない場合はエラーになる。
4340
4341                 ファイルを削除するには|delete()|を使う。
4342
4343 rename({from}, {to})                                    *rename()*
4344                 ファイルの名前を{from}から{to}へ変える。ファイルシステムを越え
4345                 てファイルを移動するのにも使用できる。結果は数値で、成功すれば
4346                 0、失敗すれば非ゼロになる。
4347                 NOTE: ファイル {to} がすでに存在する場合、警告なしに上書きされ
4348                 る。
4349                 |sandbox|の中ではこの関数は利用できない。
4350
4351 repeat({expr}, {count})                                 *repeat()*
4352                 {expr}を{count}回繰り返し、連結して返す。例: >
4353                         :let separator = repeat('-', 80)
4354 <               {count}が0または負のときは空文字列を返す。{expr}がリスト
4355                 |List|のときは{count}回連結した結果を返す。例: >
4356                         :let longlist = repeat(['a', 'b'], 3)
4357 <               結果は['a', 'b', 'a', 'b', 'a', 'b']となる。
4358
4359
4360 resolve({filename})                                     *resolve()* *E655*
4361                 MS-Windowsでは{filename}がショートカット(.lnkファイル)ならばそ
4362                 の指す先を単純化した形式で返す。
4363                 Unixではパス{filename}の中の全てのシンボリックリンクを解決し、
4364                 単純化して返す。循環リンクがある場合に備えて、シンボリックリン
4365                 クの解決は100回までに制限されている。
4366                 その他のシステムでは{filename}を単純化して返す。
4367                 単純化の手順は|simplify()|と同じである。
4368                 resolve()は(結果も相対パスであるならば)カレントディレクトリを
4369                 表す先頭のパスコンポーネントと、末尾のパス区切り文字をそのまま
4370                 にする。
4371
4372                                                         *reverse()*
4373 reverse({list}) {list}の要素の順序をその場で(in-place)反転させる。{list}そのも
4374                 のを返す。
4375                 リストを変更させないでおくには、最初にコピーを作る: >
4376                         :let revlist = reverse(copy(mylist))
4377
4378 round({expr})                                                   *round()*
4379                 {expr} を最も近い整数に丸め、|Float| を返す。{expr} が二つの整
4380                 数の真ん中にある場合、大きい方(0 から遠い方)になる。
4381                 (訳注: つまり四捨五入になる)
4382                 {expr} は |Float| または |Number| に評価されなければならない。
4383                 例: >
4384                         echo round(0.456)
4385 <                       0.0  >
4386                         echo round(4.5)
4387 <                       5.0 >
4388                         echo round(-4.5)
4389 <                       -5.0
4390                 {|+float| 機能つきでコンパイルされたときのみ有効}
4391
4392
4393 search({pattern} [, {flags} [, {stopline} [, {timeout}]]])      *search()*
4394                 正規表現パターン{pattern}を検索する。検索はカーソル位置から開
4395                 始する(検索位置を指定するには|cursor()|を使えばよい)。
4396
4397                 {flags} は以下のフラグ文字からなる文字列
4398                 'b'     後方(上方)に検索する
4399                 'c'     カーソル位置のマッチを受け入れる
4400                 'e'     マッチの末尾へ移動する
4401                 'n'     カーソルを移動させない
4402                 'p'     部分パターン(後述)のマッチの番号を返す
4403                 's'     以前のカーソル位置をマーク'に記録する
4404                 'w'     ファイルの末尾で循環する
4405                 'W'     ファイルの末尾で循環しない
4406                 'w'と'W'の両方とも指定されない場合は'wrapscan'が適用される。
4407
4408                 フラグ's'が指定された場合、カーソルが移動したときのみマーク'が
4409                 設定される。フラグ's'は'n'と組み合わせることはできない。
4410
4411                 'ignorecase', 'smartcase', 'magic'が適用される。
4412
4413                 引数{stopline}が指定されたときはこの行を検索した後で検索を停止
4414                 する。これは検索する行を制限するために有用である。例: >
4415                         let match = search('(', 'b', line("w0"))
4416                         let end = search('END', '', line("w$"))
4417 <               {stopline}に0でない値が指定されたときは、暗黙にファイルの末尾
4418                 で循環しなくなる。
4419                 0 の値は、引数を省略したときと同じになる。
4420
4421                 {timeout} が指定された場合、そのミリ秒が経過したところで検索が
4422                 停止する。つまり、{timeout} が 500 なら検索は 500 ミリ秒で停止
4423                 する。
4424                 この値は負であってはならない。0 の値は、引数を省略したときと同
4425                 じになる。
4426                 {|+reltime| 機能つきでコンパイルされたときのみ有効}
4427
4428                 マッチがない場合は0を返し、カーソルは移動しない。エラーメッセ
4429                 ージは表示されない。
4430                 マッチが見つかった場合はその行番号を返す。
4431                                                         *search()-sub-match*
4432                 フラグ 'p' を指定すると、戻り値は \(\) によるグループ化のうち
4433                 最初にマッチしたものの番号プラス 1 となる。パターン全体はマッ
4434                 チしたがどのグループもマッチしなかったときは 1 を返す。
4435                 桁番号を取得するには|searchpos()|を使う。
4436
4437                 フラグ'n'が指定されていない場合、マッチ位置にカーソルが移動す
4438                 る。
4439
4440                 例 (引数リストの全ファイルにわたって検索して置換する): >
4441                     :let n = 1
4442                     :while n <= argc()   " arglist中の全ファイルに対してループ
4443                     :  exe "argument " . n
4444                     :  " ファイルの最後の文字から開始し、循環してファイルの
4445                     :  " 最初から検索する
4446                     :  normal G$
4447                     :  let flags = "w"
4448                     :  while search("foo", flags) > 0
4449                     :    s/foo/bar/g
4450                     :    let flags = "W"
4451                     :  endwhile
4452                     :  update       " 修正されていればファイルを保存する
4453                     :  let n = n + 1
4454                     :endwhile
4455 <
4456                 フラグの使い方の例: >
4457                     :echo search('\<if\|\(else\)\|\(endif\)', 'ncpe')
4458 <               このコマンドは、カーソル下の文字以降からキーワード"if",
4459                 "else","endif"のいずれかを検索する。フラグ'p'により、どのキー
4460                 ワードが見つかったかに応じて1,2,3を返す。見つからなかったとき
4461                 は0を返す。次の行の最初の単語にカーソルをおいて上のコマンドを
4462                 実行すると:
4463                     if (foo == 0) | let foo = foo + 1 | endif ~
4464                 1が返る。フラグ'c'を外すと"endif"にマッチし3を返すようになる。
4465                 カーソルを"if"の"f"の上におき、フラグ'e'を外して実行しても同じ
4466                 く3が返る。フラグ'n'によりカーソルは移動しない。
4467
4468
4469 searchdecl({name} [, {global} [, {thisblock}]])                 *searchdecl()*
4470                 {name}の宣言を検索する。
4471
4472                 {global}が0でないときは|gD|と同じようにファイル中の最初のマッ
4473                 チを探す。そうでないときは|gd|と同じ動作になり、現在の関数内か
4474                 ら最初のマッチを探す。
4475
4476                 {thisblock}が0でないときはカーソル位置より前の位置で閉じている
4477                 {}ブロックを無視し、そのスコープ内でだけ有効な変数宣言にマッチ
4478                 しないようになる。
4479
4480                 マッチを見つけるとその位置へカーソルを移動する。
4481                 成功すると0を返し、失敗すると非0を返す。
4482                 例: >
4483                         if searchdecl('myvar') == 0
4484                            echo getline('.')
4485                         endif
4486 <
4487                                                         *searchpair()*
4488 searchpair({start}, {middle}, {end} [, {flags} [, {skip}
4489                                 [, {stopline} [, {timeout}]]]])
4490                 ネストしたstart・endのペアを検索する。これを使うと、"if"に対応
4491                 する"endif"を見つけることができる。それらの間にある他のif・
4492                 endifのペアは無視される。
4493                 検索はカーソル位置から開始する。デフォルトでは下方に検索する。
4494                 {flags}に'b'が含まれていると上方に検索する。
4495                 マッチが見つかると、その位置へカーソルを移動し、行番号を返す。
4496                 マッチが見つからなかったときは0または-1を返し、カーソルは移動
4497                 しない。エラーメッセージは表示されない。
4498
4499                 {start}、{middle}、{end}は正規表現である。|pattern|を参照。こ
4500                 の正規表現に \( \) のペアを含めてはならない。\%( \) は含めても
4501                 よい。{middle}はネストしたstart・endペアの中にないときのみマッ
4502                 チする。典型的な使用例: >
4503                         searchpair('\<if\>', '\<else\>', '\<endif\>')
4504 <               ここで{middle}を空にすると"else"をスキップするようになる。
4505
4506                 {flags}には|search()|と同様に'b', 'c', 'n', 's', 'w', 'W' が使
4507                 える。それに加えて以下のフラグが利用できる。
4508                 'r'     それ以上マッチが見つからなくなるまで繰り返す。つまり最
4509                         も外側のペアを探す。'W' も自動的にオンになる。
4510                 'm'     マッチ位置の行番号でなくマッチの個数を返す。'r'を使っ
4511                         ているときは > 1 となる。
4512                 Note: ほとんどつねに 'W' を使ってファイルの末尾で循環しないよ
4513                 うにするのがよい考えである。
4514
4515                 {start}、{middle}、{end}のマッチが見つかると、マッチの開始位置
4516                 にカーソルを移動し、式{skip}を評価する。このマッチがコメントや
4517                 文字列の内側にある場合など、無視したいものであれば式{skip}が
4518                 非0を返すようにする。
4519                 {skip}を省略した、または空のときはどのマッチも無視しない。
4520                 {skip}を評価している最中にエラーが発生すると、検索は異常終了し
4521                 -1を返す。
4522
4523                 {stopline} と {timeout} については|search()|を参照。
4524
4525                 'ignorecase'の値が適用される。'magic'の値は無視され、オンのと
4526                 きと同じ様に動作する。
4527
4528                 検索はカーソル位置から開始する。検索方向の次の文字における
4529                 {start}、{middle}、{end}のマッチが最初に見つかる。例: >
4530                         if 1
4531                           if 2
4532                           endif 2
4533                         endif 1
4534 <               カーソルが"if 2"の"i"の上にある状態から下方に検索を開始すると
4535                 "endif 2"にマッチする。"if 2"の直前の文字の上から検索を開始す
4536                 ると"endif 1"にマッチする。これは、"if 2"が最初に見つかり、
4537                 "if 2"から"endif 2"までがネストしたペアと見なされるためである。
4538                 上方検索で、{end}が2文字以上であるときはパターンの最後に"\zs"
4539                 をつけるとよいかもしれない。するとカーソルがendのマッチの内
4540                 側にあるとき、対応するstartを見つけるようになる。
4541
4542                 例: Vimスクリプトの"endif"コマンドを見つけるには: >
4543
4544         :echo searchpair('\<if\>', '\<el\%[seif]\>', '\<en\%[dif]\>', 'W',
4545                         \ 'getline(".") =~ "^\\s*\""')
4546
4547 <               これを使うには、マッチを見つけたい"if"の上、またはそれ以降にカ
4548                 ーソルを置くこと。Note バックスラッシュを二重にしなくてもよい
4549                 ようにシングルクォート文字列を使っている。式skipにより、コメン
4550                 トだけの行を無視するようにしている。コマンドの後のコメントは無
4551                 視していない。また、行の途中の"en"や"if"という単語にマッチして
4552                 しまう。
4553                 もう1つの例: "}"に対応する"{"を検索する: >
4554
4555         :echo searchpair('{', '', '}', 'bW')
4556
4557 <               これを使うには、マッチを見つけたい"}"の上、または前にカーソル
4558                 を置くこと。構文ハイライトにより文字列と見なされるマッチを無視
4559                 するには次のようにする: >
4560
4561         :echo searchpair('{', '', '}', 'bW',
4562              \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')
4563 <
4564                                                         *searchpairpos()*
4565 searchpairpos({start}, {middle}, {end} [, {flags} [, {skip}
4566                                 [, {stopline} [, {timeout}]]]])
4567                 |searchpair()|と同様だが、マッチの行番号と桁番号からなるリスト
4568                 |List|を返す。このリストの最初の要素は行番号で、次の要素はマッ
4569                 チの桁位置のバイトインデックスである。マッチが見つからなかった
4570                 場合は[0, 0]を返す。
4571 >
4572                         :let [lnum,col] = searchpairpos('{', '', '}', 'n')
4573 <
4574                 より大規模で役に立つ例に関しては|match-parens|を参照。
4575
4576 searchpos({pattern} [, {flags} [, {stopline} [, {timeout}]]])   *searchpos()*
4577                 |search()|と同様だが、マッチの行番号と桁番号からなるリスト
4578                 |List|を返す。このリストの最初の要素は行番号で、次の要素はマッ
4579                 チの桁位置のバイトインデックスである。マッチが見つからなかった
4580                 場合は[0, 0]を返す。
4581                 例: >
4582         :let [lnum, col] = searchpos('mypattern', 'n')
4583
4584 <               フラグ'p'を指定すると、戻り値にサブパターンのマッチ番号を示す
4585                 要素が加わる|search()-sub-match|。例: >
4586         :let [lnum, col, submatch] = searchpos('\(\l\)\|\(\u\)', 'np')
4587 <               この例において、"submatch"は小文字|/\l|が見つかったとき2とな
4588                 り、大文字|/\u|が見つかったとき3となる。
4589
4590 server2client( {clientid}, {string})                    *server2client()*
4591                 {clientid}に返信文字列を送る。最後に文字列を送った{clientid}は
4592                 expand("<client>")で取得できる。
4593                 {|+clientserver|機能付きでコンパイルしたときのみ利用可能}
4594                 Note:
4595                 このIDは次のコマンドを受け取る前に取得しなければならない。つま
4596                 り、受け取ったコマンドから戻る前で、入力を待つコマンドを呼ぶ前。
4597                 |clientserver|も参照。
4598                 例: >
4599                         :echo server2client(expand("<client>"), "HELLO")
4600 <
4601 serverlist()                                    *serverlist()*
4602                 利用可能なサーバ名のリストを返す。1行に1つの形式。
4603                 サーバが1つもないとき、または情報を取得できないときは空文字列
4604                 を返す。|clientserver|も参照。
4605                 {|+clientserver|機能付きでコンパイルしたときのみ利用可能}
4606                 例: >
4607                         :echo serverlist()
4608 <
4609 setbufvar({expr}, {varname}, {val})                     *setbufvar()*
4610                 バッファ{expr}のオプションまたはローカル変数{varname}に{val}を
4611                 代入する。
4612                 グローバル・ウィンドウローカルオプションに対しても動作するが、
4613                 グローバル・ウィンドウローカル変数に対しては動作しない。
4614                 ウィンドウローカルオプションの場合、グローバルな値は変更されな
4615                 い。
4616                 {expr}の解釈の仕方については|bufname()|を参照。
4617                 Note 変数名には"b:"をつけてはならない。
4618                 例: >
4619                         :call setbufvar(1, "&mod", 1)
4620                         :call setbufvar("todo", "myvar", "foobar")
4621 <               サンドボックスの中ではこの関数は使用できない。
4622
4623 setcmdpos({pos})                                        *setcmdpos()*
4624                 コマンドラインの{pos}バイトの位置へカーソルを移動する。
4625                 {pos}は1から始まる。
4626                 現在の位置を取得するには|getcmdpos()|を使う。
4627                 コマンドラインを編集している最中のみ機能する。よって、
4628                 |c_CTRL-\_e|、|c_CTRL-R_=|、|c_CTRL-R_CTRL-R|＋'='と組み合
4629                 わせて使うときだけ意味がある。|c_CTRL-\_e|と|c_CTRL-R_CTRL-R|
4630                 ＋'='の場合、コマンドラインにその式をセットした後でカーソルを
4631                 移動する。|c_CTRL-R_=|の場合、式を評価した後、結果のテキストを
4632                 挿入する前にカーソルを移動する。
4633                 {pos}が大きすぎるときは行末にカーソルを移動する。{pos}が1より
4634                 小さいときの結果は未定義である。
4635                 成功なら0、コマンドラインを編集しているとき以外には1を返す。
4636
4637 setline({lnum}, {text})                                 *setline()*
4638                 カレントバッファの{lnum}行目を{text}にする。
4639                 {lnum}は|getline()|のときと同じように解釈される。
4640                 {lnum}が最後の行の次の行の場合、新規行として{text}を追加する。
4641                 成功したら0を返す。失敗したら(大抵{lnum}が無効な値のとき)1を返
4642                 す。例: >
4643                         :call setline(5, strftime("%c"))
4644 <               {line}がリスト|List|の場合、{lnum}行目とそれ以降の行にリストの
4645                 要素をセットする。例: >
4646                         :call setline(5, ['aaa', 'bbb', 'ccc'])
4647 <               上の例は次と同値である: >
4648                         :for [n, l] in [[5, 6, 7], ['aaa', 'bbb', 'ccc']]
4649                         :  call setline(n, l)
4650                         :endfor
4651 <               Note: マーク '[ と '] はセットされない。
4652
4653 setloclist({nr}, {list} [, {action}])                   *setloclist()*
4654                 ウィンドウ{nr}のロケーションリストを作成・置き換え・追加する。
4655                 {nr}が0のときはカレントウィンドウを対象にする。ロケーションリ
4656                 ストウィンドウの場合、そこに表示しているロケーションリストが修
4657                 正される。ウィンドウ番号{nr}が無効な場合、-1を返す。
4658                 それ以外は|setqflist()|と同じ。
4659                 |location-list| も参照。
4660
4661 setmatches({list})                                      *setmatches()*
4662                 |getmatches()| で取得したマッチのリストを復元する。成功なら
4663                 0、失敗なら -1 を返す。リストを復元するに先立って、現在のマッ
4664                 チはすべて消去される。|getmatches()| の例を参照。
4665
4666                                                         *setpos()*
4667 setpos({expr}, {list})
4668                 {expr}の位置を設定する。{expr}として有効な値は次の通り:
4669                         .       カーソル位置
4670                         'x      マーク x
4671
4672                 {list}は次の4個のの要素を持つリスト|List|でなければならない:
4673                     [bufnum, lnum, col, off]
4674
4675                 "bufnum"はバッファ番号。0にするとカレントバッファを表す。カー
4676                 ソル位置の設定はカレントバッファに対してのみ可能。他のバッファ
4677                 のマークを設定するには、関数|bufnr()|を使ってファイル名をバッ
4678                 ファ番号に変換する。
4679                 ジャンプリストは変更されない。
4680
4681                 "lnum"と"col"はバッファ内の位置。桁番号は1から始まる。"lnum"を
4682                 0にするとそのマークを削除する。
4683
4684                 数値"off"は'virtualedit'がオンのときのみ使われ、その文字の開始
4685                 位置からの画面上の桁のオフセットとなる。例えば、<Tab>の中、ま
4686                 たは最後の文字より後に設定したいときに使う。
4687
4688                 位置をセットできたときは 0 を、そうでなければ -1 を返す。
4689                 {expr} が無効なときはエラーメッセージが出る。
4690
4691                 |getpos()|も参照。
4692
4693                 縦方向に移動するときの望ましい桁を復元しない。それには
4694                 |winrestview()|を参照。
4695
4696
4697 setqflist({list} [, {action}])                          *setqflist()*
4698                 {list}の要素によりQuickFixリストを作成・置き換え・追加する。
4699                 {list}の各要素は辞書であること。
4700                 辞書でない{list}の要素は無視される。各辞書は以下の要素を
4701                 持つ:
4702
4703                     bufnr       バッファ番号。有効なバッファ番号でなければなら
4704                                 ない。
4705                     filename    ファイル名。"bufnr"がないとき、または無効であ
4706                                 るときのみ使われる。
4707                     lnum        ファイル中の行番号
4708                     pattern     エラーの位置を特定するための検索パターン
4709                     col         桁番号
4710                     vcol        0でない場合: "col"は表示上の桁
4711                                 0の場合: "col"はバイトインデックス
4712                     nr          エラー番号
4713                     text        エラーの説明
4714                     type        エラータイプを示す1文字。'E', 'W'など。
4715
4716                 辞書の要素"col"、"vcol"、"nr"、"type"、"text"は省略可能である。
4717                 "lnum"か"pattern"のどちらか一方のみがエラー行を特定するために
4718                 使われる。"filename"と"bufnr"の両方ともない場合、または"lnum"
4719                 と"pattern"の両方ともない場合、その要素はエラー行として扱われ
4720                 ない。"pattern"と"lnum"の両方があるときは"pattern"が使われる。
4721                 このリストは|getqflist()|が返すものと正確に同じではないことに
4722                 注意。
4723
4724                 {action}が'a'ならば{list}の要素を既存のQuickFixリストに追加す
4725                 る。QuickFixリストがまだ存在しない場合は新規に作成される。
4726                 {action}が'r'ならば{list}の要素で現在のQuickFixリストを置き換
4727                 える。{action}が指定されないとき、または' 'のときは新しい
4728                 QuickFixリストを作成する。
4729
4730                 成功なら0、失敗なら-1を返す。
4731
4732                 この関数は'errorformat'の設定とは無関係にQuickFixリストを作る
4733                 ために使える。その最初のエラーへジャンプするには":cc 1"などの
4734                 コマンドを使う。
4735
4736
4737                                                         *setreg()*
4738 setreg({regname}, {value} [,{options}])
4739                 レジスタ{regname}に{value}をセットする。
4740                 {options}が"a"を含んでいるとき、または{regname}が大文字のとき
4741                 は、その値に追加する。
4742                 {options}は以下のレジスタの種類指定を含んでもよい:
4743                     "c" または "v"       |characterwise| モード
4744                     "l" または "V"       |linewise| モード
4745                     "b" または "<CTRL-V>"     |blockwise-visual| モード
4746                 "b"または"<CTRL-V>"の直後に数値を続けると、それが選択範囲の幅
4747                 となる。これを指定しない場合、選択範囲の幅は一番長い行の文字数
4748                 となる(<Tab>は1文字と数えられる)。
4749
4750                 {options}にレジスタの設定が何も含まれていないとき、{value}が
4751                 <NL>で終わっていない限り、デフォルトの文字指向モードが使われる。
4752                 レジスタ'='の値を設定することはできない。
4753                 成功なら0、失敗なら非0を返す。
4754
4755                 例: >
4756                         :call setreg(v:register, @*)
4757                         :call setreg('*', @%, 'ac')
4758                         :call setreg('a', "1\n2\n3", 'b5')
4759
4760 <               次の例は、この関数を使ってレジスタを退避・復元する例である。 >
4761                         :let var_a = getreg('a', 1)
4762                         :let var_amode = getregtype('a')
4763                             ....
4764                         :call setreg('a', var_a, var_amode)
4765
4766 <               空文字列を追加すると、レジスタの種類を変更することができる: >
4767                         :call setreg('a', '', 'al')
4768
4769 settabwinvar({tabnr}, {winnr}, {varname}, {val})        *settabwinvar()*
4770                 ウィンドウ{winnr}のオプションやローカル変数{varname}の値を
4771                 {val}にセットする。
4772                 タブ番号は1から始まる。カレントタブページを対象とする場合は
4773                 |setwinvar()|を使う。
4774                 {winnr}が0のときはカレントウィンドウが対象となる。
4775                 グローバルオプションやバッファローカルオプションを設定すること
4776                 もできるが、グローバル変数やバッファローカル変数を設定すること
4777                 はできない。
4778                 バッファローカルオプションを設定した場合、グローバル値は変更さ
4779                 れない。
4780                 Note 変数名には"w:"をつけてはならない。
4781                 内部的に、一時的にタブページ{tabnr}に移動する。そのためオート
4782                 コマンドTabLeaveとTabEnterが発生する。
4783                 例: >
4784                         :call settabwinvar(1, 1, "&list", 0)
4785                         :call settabwinvar(3, 2, "myvar", "foobar")
4786 <               この関数は|sandbox|の中では使用できない。
4787
4788 setwinvar({nr}, {varname}, {val})                       *setwinvar()*
4789                 |settabwinvar()|と同様。カレントタブページを対象とする。
4790                 例: >
4791                         :call setwinvar(1, "&list", 0)
4792                         :call setwinvar(2, "myvar", "foobar")
4793
4794 shellescape({string} [, {special}])                     *shellescape()*
4795                 シェルコマンドの引数として利用できるように{string}をエスケープ
4796                 する。
4797                 MS-WindowsとMS-DOSでは、'shellslash'が設定されていない場合、
4798                 {string}をダブルクォートで囲み、{string}の中のダブルクォートを
4799                 全て二重にする。
4800                 他のシステムでは、{string}をシングルクォートで囲み、"'"を
4801                 "'\''"で置き換える。
4802                 {special} が指定され、0 でない数値または空でない文字列の場合
4803                 (|non-zero-arg|)、"!", "%", "#", "<cword>" などの特殊なアイテ
4804                 ムの前にはバックスラッシュがつく。コマンド |:!| に
4805                 よってそのバックスラッシュは再び除かれる。
4806                 'shell' の値の末尾が "csh" である場合、{special} が
4807                 |non-zero-arg| ならば"!" の文字もエスケープされる。これは、csh
4808                 と tcsh は シングルクォートの中であっても "!" を履歴置換と解釈
4809                 するためである。
4810                 <NL> 文字もエスケープされる。{special} が |non-zero-arg| であ
4811                 り 'shell' の末尾が "csh" である場合、これは2回エスケープされ
4812                 る。
4813                 |:!| コマンドを使う場合の例: >
4814                     :exe '!dir ' . shellescape(expand('<cfile>'), 1)
4815 <               これはカーソル下のファイルを dir コマンドで表示する。
4816                 |system()| を使う場合の例: >
4817                     :call system("chmod +w -- " . shellescape(expand("%")))
4818
4819
4820 simplify({filename})                                    *simplify()*
4821                 ファイル名を、意味を変えずにできるだけ簡略化する。MS-Windowsで
4822                 のショートカットやUnixでのシンボリックリンクは解決される。
4823                 {filename}の最初のパスコンポーネントがカレントディレクトリを指
4824                 す場合、結果にそのまま残される。末尾のパス区切り文字も取り除か
4825                 れない。
4826                 例: >
4827                         simplify("./dir/.././/file/") == "./file/"
4828 <               Note: "dir/.."の組み合わせは、"dir"が検索可能なディレクトリで
4829                 あるか、存在しないときのみ取り除かれる。Unixでは、"dir"が同じ
4830                 ディレクトリ内にあるシンボリックリンクであるときも取り除かれる。
4831                 パス名を簡略化する前に全てのシンボリックリンクを解決させるには
4832                 |resolve()|を使う。
4833
4834
4835 sin({expr})                                             *sin()*
4836                 {expr} の正接(サイン)をラジアンで |Float| で返す。{expr} は
4837                 |Float| または |Number| に評価されなければならない。
4838                 例: >
4839                         :echo sin(100)
4840 <                       -0.506366 >
4841                         :echo sin(-4.01)
4842 <                       0.763301
4843                 {|+float| 機能つきでコンパイルされたときのみ有効}
4844
4845
4846 sort({list} [, {func}])                                 *sort()* *E702*
4847                 {list}の要素をその場で(in-place)ソートする。{list}を返す。リス
4848                 トを変更したくない場合は、最初にコピーを作っておくこと: >
4849                         :let sortedlist = sort(copy(mylist))
4850 <               ソートの際には、各要素の文字列表現を使う。
4851                 数値は文字列より後になり、リストは数値より後になる。
4852                 カレントバッファのテキストをソートするには|:sort|を使うこと。
4853                 {func}に1を指定すると、大文字・小文字を区別しなくなる。
4854                 {func}に|Funcref|または関数名を指定すると、その関数を使って要
4855                 素を比較する。その関数は2つの要素を引数として受け取り、それら
4856                 が等しいときは0、1番目の引数を2番目より後にするなら1以上、1番
4857                 目の方を前にするなら-1以下を返す。例: >
4858                         func MyCompare(i1, i2)
4859                            return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
4860                         endfunc
4861                         let sortedlist = sort(mylist, "MyCompare")
4862 <               この例の場合、より短く次のように書くことができる。ただしオーバー
4863                 フローは無視される: >
4864                         func MyCompare(i1, i2)
4865                            return a:i1 - a:i2
4866                         endfunc
4867 <
4868                                                         *soundfold()*
4869 soundfold({word})
4870                 {word}と同値でsound-foldされた単語を返す。カレントウィンドウの
4871                 'spelllang'で設定された言語のうち、soundfoldingに対応する最初の
4872                 言語が使用される。'spell'がオンでなければならない。
4873                 soundfoldingができない場合、{word}がそのまま返される。
4874                 この関数はスペリング候補を作るために使われる。Note この方法は
4875                 とても遅くなる可能性がある。
4876
4877                                                         *spellbadword()*
4878 spellbadword([{sentence}])
4879                 引数なしの場合: カーソル下またはカーソル以降のスペルミスした単
4880                 語を返す。その単語の先頭へカーソルを移動する。カレント行にスペ
4881                 ルミスした単語が見つからない場合は空文字列を返し、カーソルは移
4882                 動しない。
4883
4884                 引数ありの場合: {sentence}の中のスペルミスしている最初の単語を
4885                 返す。スペルミスしている単語がない場合は空文字列を返す。
4886
4887                 戻り値は、次の2個の要素を持つリスト:
4888                 - スペルミスした単語または空文字列
4889                 - スペルミスの種類:
4890                         "bad"           スペルミス
4891                         "rare"          頻度の低い単語
4892                         "local"         他の地域でのみ有効な単語
4893                         "caps"          大文字で始めるべき単語
4894                 例: >
4895                         echo spellbadword("the quik brown fox")
4896 <                       ['quik', 'bad'] ~
4897
4898                 カレントウィンドウに対するスペリング情報が適用される。オプショ
4899                 ン'spell'がオンでなければならない。'spelllang'の値が使用される。
4900
4901                                                         *spellsuggest()*
4902 spellsuggest({word} [, {max} [, {capital}]])
4903                 {word}の正しいスペルの候補のリストを返す。{max}を指定すると、
4904                 候補の数の最大値となる。{max}を指定しないと、25個までの候補を
4905                 返す。
4906
4907                 {capital}に0でない値を指定すると、先頭が大文字の候補だけを返す。
4908                 これは'spellcapcheck'とのマッチの後に使う。
4909
4910                 {word}はスペルの間違った単語で、後に他のテキストが続いてもよい。
4911                 これにより、分割された2つの単語を連結することができる。候補も
4912                 また続きのテキストを含んでいるので、これによって行を置き換える
4913                 ことができる。
4914
4915                 {word}は正しい単語でもよい。すると似た単語が返ってくるだろう。
4916                 {word}自身は候補に含まれないが、大文字化されたものが含まれてい
4917                 ることはある。
4918
4919                 カレントウィンドウのスペリング情報が使われる。オプション
4920                 'spell'がオンでなければならず、'spelllang'と'spellsuggest'の値
4921                 が適用される。
4922
4923
4924 split({expr} [, {pattern} [, {keepempty}]])                     *split()*
4925                 {expr}を分割して|List|にする。{pattern}を省略した場合、または
4926                 {pattern}が空文字列の場合は、{expr}を空白文字で区切った各文字
4927                 列が要素となる。
4928                 {pattern}を指定すると、{pattern}がマッチする位置で文字列を分割
4929                 する。マッチした文字列は削除される。
4930                 {keepempty}に非0を指定しない限り、最初または最後の要素が空文字
4931                 列ならばリストから取り除かれる。
4932                 それ以外の空文字列は、{pattern}が1文字以上にマッチすれば、また
4933                 は{keepempty}が非0ならばそのままリストの要素となる。
4934                 例: >
4935                         :let words = split(getline('.'), '\W\+')
4936 <               文字列を各文字に分割するには: >
4937                         :for c in split(mystring, '\zs')
4938 <               区切り文字を削除せず、そのままにしておきたい場合は、'\zs'を
4939                 使えばよい: >
4940                         :echo split('abc:def:ghi', ':\zs')
4941 <                       ['abc:', 'def:', 'ghi'] ~
4942                 最初の要素が空であるかもしれないテーブルを分割するには: >
4943                         :let items = split(line, ':', 1)
4944 <               これの逆を行う関数は|join()|である。
4945
4946
4947 sqrt({expr})                                            *sqrt()*
4948                 浮動小数点数 {expr} の非負平方根を |Float| で返す。
4949                 {expr} は |Float| または |Number| に評価されなければならな
4950                 い。{expr} が負の場合、結果は NaN (Not a Number) になる。
4951                 例: >
4952                         :echo sqrt(100)
4953 <                       10.0 >
4954                         :echo sqrt(-4.01)
4955 <                       nan
4956                 "nan" はシステムのライブラリに依存するので、異なるかもしれな
4957                 い。
4958                 {|+float| 機能つきでコンパイルされたときのみ有効}
4959
4960
4961 str2float( {expr})                                      *str2float()*
4962                 文字列 {expr} を浮動小数点数に変換する。これは式の中で浮動小数
4963                 点数を使っているときと同じようにはたらく
4964                 (|floating-point-format| を参照)。しかしこちらの方がゆるやか
4965                 である。例えばこちらでは "1e40" も許されるが、式の中では
4966                 "1.0e+40" と書かなければならない。
4967                 数値の後ろにある文字列は黙って無視される。
4968                 小数点数はロケールの設定にかかわらずつねに '.' である。コンマ
4969                 を発見すると、そこで数値は終りになる。つまり "12,345.67" は
4970                 12.0 に変換される。3桁ごとのカンマ区切りを取り除くには
4971                    |substitute()| が使える: >
4972                         let f = str2float(substitute(text, ',', '', 'g'))
4973 <               {|+float| 機能つきでコンパイルされたときのみ有効}
4974
4975 str2nr( {expr} [, {base}])                              *str2nr()*
4976                 文字列{expr}を数値に変換する。
4977                 {base}は変換の底。8、10、16のいずれか。
4978                 {base}を省略すると10となる。そのため、文字列の先頭に0があると
4979                 き、デフォルトの文字列・数値変換とは異なり、8進数とは解釈され
4980                 ない。
4981                 {base}が16のとき、文字列の先頭の"0x"と"0X"は無視される。それ以
4982                 外の底の場合は0となる。
4983                 数値の後のテキストは暗黙に無視される。
4984
4985                                                         *strftime()*
4986 strftime({format} [, {time}])
4987                 結果は文字列で、{format}に従って日付や時間がフォーマットされた
4988                 ものになる。{time}が与えられた場合にはそれを使うが、省略された
4989                 場合には現在時刻を使用する。受け付け可能な文字列{format}は使用
4990                 するシステムに依存するので、ポータブルとは言えない。フォーマッ
4991                 トについてはCの関数strftime()のマニュアルを参照。結果は最大80
4992                 文字に制限される。|localtime()|と|getftime()|も参照。
4993                 ここで使われる言語はコマンド|:language|で変更できる。
4994                 例: >
4995                   :echo strftime("%c")             Sun Apr 27 11:49:23 1997
4996                   :echo strftime("%Y %b %d %X")    1997 Apr 27 11:53:25
4997                   :echo strftime("%y%m%d %T")      970427 11:53:55
4998                   :echo strftime("%H:%M")          11:55
4999                   :echo strftime("%c", getftime("file.c"))
5000                                                    file.cの更新時刻を表示
5001 <               この関数はどのシステムでも利用できるとは限らない。利用できるか
5002                 チェックするには次のようにする: >
5003                         :if exists("*strftime")
5004
5005 stridx({haystack}, {needle} [, {start}])                *stridx()*
5006                 結果は数値で、{heystack}の中で文字列{needle}が最初に現れる位置
5007                 のバイトインデックスを表す。{start}を指定すると、インデックス
5008                 {start}の位置から検索を開始する。
5009                 2番目のマッチを探すには次のようにする: >
5010                         :let comma1 = stridx(line, ",")
5011                         :let comma2 = stridx(line, ",", comma1 + 1)
5012 <               検索は大文字・小文字を区別する。
5013                 検索パターンについては|match()|を使う。
5014                 {haystack}の中に{needle}がないときは-1を返す。
5015                 |strridx()|も参照。
5016                 例: >
5017                   :echo stridx("An Example", "Example")      3
5018                   :echo stridx("Starting point", "Start")    0
5019                   :echo stridx("Starting point", "start")   -1
5020 <                                               *strstr()* *strchr()*
5021                 stridx()はCの関数strstr()と同じように動作する。{needle}が1文字
5022                 のときはstrchr()と同じように動作する。
5023
5024                                                         *string()*
5025 string({expr})  {expr}を文字列に変換して返す。{expr}が数値、浮動小数点数、文字
5026                 列、それらの複合の場合は、この戻り値を|eval()|でパースして復元
5027                 できる。
5028                         {expr} 型        結果 ~
5029                         文字列             'string'
5030                         数値              123
5031                         浮動小数点数  123.123456 or 1.123456e8
5032                         Funcref         function('name')
5033                         リスト             [item, item]
5034                         辞書              {key: value, key: value}
5035                 Note 文字列中のシングルクォート(')は二重化される。
5036                 |strtrans()|も参照。
5037
5038                                                         *strlen()*
5039 strlen({expr})  結果は数値で、文字列{expr}の長さ。
5040                 マルチバイト文字の個数を数えるには次のようなことをする(合成文
5041                 字は数えない): >
5042
5043                         :let len = strlen(substitute(str, ".", "x", "g"))
5044 <
5045                 引数が数値の場合は、まず文字列に変換される。
5046                 それ以外の型の場合はエラーとなる。
5047                 |len()|も参照。
5048
5049
5050                                                         *strpart()*
5051 strpart({src}, {start}, {len})
5052                 結果は文字列で、{src}の{start}番目の文字から始まる、長さ{len}
5053                 の部分文字列。存在しない文字を含むように範囲を指定しても、エ
5054                 ラーにはならない。単に文字が省略されるだけである。
5055                 {len}を省略すると、{start}から{src}の末尾までの部分文字列を返
5056                 す。 >
5057                         strpart("abcdefg", 3, 2)    == "de"
5058                         strpart("abcdefg", -2, 4)   == "ab"
5059                         strpart("abcdefg", 5, 4)    == "fg"
5060                         strpart("abcdefg", 3)       == "defg"
5061 <               注意: 文字列の最初の文字を指定するためには、{start}は0でなけれ
5062                 ばならない。カーソルのある位置から3文字を取得する例: >
5063                         strpart(getline("."), col(".") - 1, 3)
5064 <
5065 strridx({haystack}, {needle} [, {start}])                       *strridx()*
5066                 結果は数値で、{haystack}の中で文字列{needle}が最後に現れる位置
5067                 のバイトインデックスとなる。
5068                 {start}を指定すると、そのインデックス以降でのマッチは無視され
5069                 る。前のマッチより前にあるものを見つけるには次のようにする: >
5070                         :let lastcomma = strridx(line, ",")
5071                         :let comma2 = strridx(line, ",", lastcomma - 1)
5072 <               検索は大文字・小文字を区別する。
5073                 検索パターンについては|match()|を使う。
5074                 {haystack}の中に{needle}がないときは-1を返す。
5075                 {needle}が空文字列のときは{haystack}の長さを返す。
5076                 |stridx()|も参照。例: >
5077                   :echo strridx("an angry armadillo", "an")          3
5078 <                                                       *strrchr()*
5079                 {needle}が1文字の場合はCの関数strrchr()と同じように動作する。
5080
5081                                                         *strtrans()*
5082 strtrans({expr})
5083                 結果は文字列で、{expr}内の表示不可能な文字を|'isprint'|で指定
5084                 される、表示可能な文字に変換したもの。ウィンドウに表示すること
5085                 ができるようになる。例: >
5086                         echo strtrans(@a)
5087 <               これはレジスタの中の改行を、改行として表示する代わりに"^@"と表
5088                 示する。
5089
5090 submatch({nr})                                          *submatch()*
5091                 |:substitute|の中の式でのみ使われる。マッチしたテキストの{nr}
5092                 番目の部分マッチを返す。{nr}が0のときはマッチしたテキスト全体
5093                 を返す。
5094                 例: >
5095                         :s/\d\+/\=submatch(0) + 1/
5096 <               この例は、行の中で最初の数値を検索し、それに1を加える。改行は
5097                 改行文字として含まれる。
5098
5099                                                         *substitute()*
5100 substitute({expr}, {pat}, {sub}, {flags})
5101                 結果は文字列で、{expr}内で最初に{pat}にマッチした部分を{sub}に
5102                 置換えたコピーになる。これはコマンド":substitute"(一切のフラグ
5103                 無し)のように働く。しかしマッチングは常にオプション'magic'が設
5104                 定され、オプション'cpoptions'は空にして実行される(スクリプトを
5105                 ポータブルにするため)。しかし'ignorecase'は適用される。
5106                 'smartcase'は適用されない。
5107                 {pat}がどう扱われるかについては|string-match|を参照。
5108                 また、{sub}内の"~"は前回の{sub}に置換されない。
5109                 {sub}内の幾つかのコードには|sub-replaced-special|の特殊な意味
5110                 があることに注意。例えば、何かの文字列をリテラルの"\n"に置換え
5111                 るためには、"\\\\n"か'\\n'を使う必要がある。
5112                 {pat}が{expr}の何処にもマッチしなければ、{expr}が何の変更も受
5113                 けずに返される。
5114                 {flags}が"g"であれば{expr}内の{pat}にマッチする全ての部分が置
5115                 換される。それを希望しない場合には{flags}は""にすべきである。
5116                 例: >
5117                         :let &path = substitute(&path, ",\\=[^,]*$", "", "")
5118 <               これはオプション'path'の最後のコンポーネントを削除する。 >
5119                         :echo substitute("testing", ".*", "\\U\\0", "")
5120 <               結果は"TESTING"となる。
5121
5122 synID({lnum}, {col}, {trans})                           *synID()*
5123                 結果は数値で、現在のウィンドウ内での位置{lnum}と{col}の位置の
5124                 構文ID。
5125                 構文IDは|synIDattr()|と|synIDtrans()|に渡すことで、テキストに
5126                 ついての構文情報を取得するのに使用できる。
5127
5128                 最左のカラムを指定するには{col}に1を、最初の行を指定するには
5129                 {line}に1を指定する。'synmaxcol'が適用され、長すぎる行では0が
5130                 返ってくる。
5131
5132                 {trans}が非ゼロならば、透過属性のアイテムは省略され、実際に表
5133                 示されているアイテムが評価対象になる。これは実際に有効になって
5134                 いるカラーを知りたい時に役に立つ。{trans}がゼロならば、透過属
5135                 性のアイテムが返される。これはどのシ構文イテムが有効になってい
5136                 るかを知りたい時に役に立つ(例:カッコの中とか)。
5137                 警告: この関数は非常に遅い。ファイルを順方向に走査する時にだけ
5138                 ベストなスピードが得られる。
5139
5140                 例(カーソルの下の構文アイテムの名前を表示する): >
5141                         :echo synIDattr(synID(line("."), col("."), 1), "name")
5142 <
5143                                                         *synIDattr()*
5144 synIDattr({synID}, {what} [, {mode}])
5145                 結果は文字列で、{synID}の属性{what}の内容を示す。これは構文
5146                 アイテムの情報を取得するのに使用できる。
5147                 {mode}には取得したいモードの属性に応じて、"gui"か"cterm"か
5148                 "term"が指定できる。{mode}が省略されるか、無効な値が指定された
5149                 場合、現在有効になっているハイライトモードが使用される(GUI、
5150                 cterm、termのどれか)
5151                 ハイライトグループにリンクされた属性を取得するにはsynIDtrans()
5152                 を使用する。
5153                 {what}          結果
5154                 "name"          構文アイテムの名前
5155                 "fg"            前景色(GUI:カラー名、cterm:文字列としてのカ
5156                                 ラー番号、term空文字列)
5157                 "bg"            背景色("fg"同様)
5158                 "sp"            特殊な色 ("fg"同様) |highlight-guisp|
5159                 "fg#"           "fg"同様だが、"#RRGGBB"のフォーマットで
5160                 "bg#"           "bg"同様だが、"#RRGGBB"のフォーマットで
5161                 "sp#"           "sp"同様だが、"#RRGGBB"のフォーマットで
5162                 "bold"          太字なら"1"
5163                 "italic"        斜体なら"1"
5164                 "reverse"       反転なら"1"
5165                 "inverse"       反転(原文inverse)なら"1"(reverseと等価)
5166                 "underline"     下線付きなら"1"
5167                 "undercurl"     波線付きなら"1"
5168
5169                 例(カーソルの下の構文アイテムの名前を表示する): >
5170         :echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg")
5171 <
5172                                                         *synIDtrans()*
5173 synIDtrans({synID})
5174                 結果は数値で、{synID}を構文IDに変換したもの。キャラク
5175                 タをハイライト表示している構文グループのIDである。
5176                 ":highlight link"によって与えられるハイライトのリンクはこれに
5177                 従っている。
5178
5179 synstack({lnum}, {col})                                 *synstack()*
5180                 カレントウィンドウの {lnum}, {col} の位置の構文アイテムのス
5181                 タックを |List| にして返す。このリストの要素は |synID()|が
5182                 返すのと同じ種類の ID である。
5183                 リストの最初の要素が一番外側の領域で、続く要素がその中に内包さ
5184                 れている。アイテム全体がハイライトされている、または最後の要素
5185                 が transparent なアイテムである場合を除き、最後の要素が
5186                 |synID()| が返すものである。
5187                 この関数は構文ファイルをデバッグするのに役に立つ。
5188                 例(カーソル下の構文スタックを表示する): >
5189                         for id in synstack(line("."), col("."))
5190                            echo synIDattr(id, "name")
5191                         endfor
5192
5193 system({expr} [, {input}])                              *system()* *E677*
5194                 シェルコマンド{expr}の実行結果を得る。
5195                 {input}が与えられた場合は、この文字列はファイルに書き出され、
5196                 コマンドの標準入力として渡される。この文字列はそのまま(as-is)
5197                 書き出され、正しい改行文字を使うよう自分自身で気を付けなければ
5198                 ならない。パイプは使われない。
5199                 注意: |shellescape()| を使ってコマンドの引数をエスケープするこ
5200                 と。{expr}内に改行が含まれるとコマンドが失敗する可能性がある。
5201                 'shellquote'と'shellxquote'に入っている文字は問題を引き起こす
5202                 かもしれない。
5203                 対話的なコマンドを使用することはできない。
5204                 戻り値は文字列。例: >
5205                     :let files = system("ls " .  shellescape(expand('%:h')))
5206
5207 <               システムに依存しないような戻り値にするために、シェルの出力をフ
5208                 ィルタリングし、マッキントッシュにおいては<CR>を<NL>に変換し、
5209                 DOS系のシステムにおいては<CR><NL>を<NL>に変換している。
5210                 実行されるコマンドはいくつかのオプションを適用して構成される:
5211         'shell' 'shellcmdflag' 'shellxquote' {expr} 'shellredir' {tmp} 'shellxquote'
5212                 ({tmp}は自動的に生成されるファイル名)
5213                 UnixとOS/2ではコマンドの連結ができるように{expr}の両側に波括弧
5214                 が置かれる。
5215
5216                 コマンドは「coocked」モードで実行される。そのためCTRL-Cでコマ
5217                 ンドを中断できる(少なくともUnixでは)。
5218
5219                 エラーコードは|v:shell_error|に格納される。
5220                 この関数は|restrict-mode|では失敗する。
5221
5222                 Note 上記のオプションに不正な値が入っていると、この関数の呼び
5223                 出しが失敗する可能性がある。セキュリティエージェントアプリケー
5224                 ションを使っていると失敗することがあるとも報告されている。
5225                 ":!cmd"とは違い、ファイルが変更されているかのチェックは行わな
5226                 い。
5227                 明示的にチェックさせるには|:checktime|を使う。
5228
5229 tabpagebuflist([{arg}])                                 *tabpagebuflist()*
5230                 カレントタブページ内の各ウィンドウに表示されているバッファの番
5231                 号を要素とするリスト|List|を返す。{arg}は対象とするタブページ
5232                 の番号を指定する。省略したときはカレントタブページを対象とする。
5233                 {arg}が無効なときは数値0を返す。
5234                 全タブページ中の全バッファのリストを得るには次のようにする: >
5235                         tablist = []
5236                         for i in range(tabpagenr('$'))
5237                            call extend(tablist, tabpagebuflist(i + 1))
5238                         endfor
5239 <               1つのバッファが複数のウィンドウに表示されている場合があること
5240                 に注意。
5241
5242
5243 tabpagenr([{arg}])                                      *tabpagenr()*
5244                 結果は数値で、カレントタブページの番号。最初のタブページの番号
5245                 は1となる。
5246                 省略可能な引数{arg}に指定できる値は"$"のみであり、最後のタブペー
5247                 ジの番号(つまりタブページの個数)を返す。
5248                 この番号はコマンド|:tab|で指定できるものと同じである。
5249
5250
5251 tabpagewinnr({tabarg}, [{arg}])                         *tabpagewinnr()*
5252                 |winnr()|と同様だが、タブページ{arg}を対象とする。
5253                 {tabarg}は対象とするタブページの番号を指定する。
5254                 {arg}は|winnr()|の場合と同じように扱われる。すなわち:
5255                 - 省略するとカレントウィンドウの番号を返す。これは、このタブペー
5256                   ジに入るとき使われるウィンドウである。
5257                 - "$"とするとウィンドウ番号を返す。
5258                 - "#"とすると前のウィンドウ番号を返す。
5259                 役に立つ例: >
5260                     tabpagewinnr(1)         " タブぺージ1のカレントウィンドウ
5261                     tabpagewinnr(4, '$')    " タブページ4内のウィンドウの個数
5262 <               {tabarg}が無効なときは0を返す。
5263
5264                                                         *tagfiles()*
5265 tagfiles()      カレントバッファにおいて、タグを検索するときに使うファイルの名
5266                 前からなるリスト|List|を返す。オプション'tags'を展開したもので
5267                 ある。
5268
5269
5270 taglist({expr})                                                 *taglist()*
5271                 正規表現{expr}にマッチするタグのリストを返す。そのリストの各要
5272                 素は辞書であり、少なくとも次の要素を持つ:
5273                         name            タグの名前。
5274                         filename        タグの定義があるファイルの名前。カレン
5275                                         トディレクトリからの相対パス、またはフ
5276                                         ルパスである。
5277                         cmd             そのファイルの中でタグの位置を特定する
5278                                         ために使うexコマンド。
5279                         kind            タグの種類。種類は言語に依存する。この
5280                                         要素は、Exuberant ctagsかhdrtagによって
5281                                         生成されたタグファイルを使っているとき
5282                                         のみ使用できる。
5283                         static          ファイル固有のタグ。より詳しくは
5284                                         |static-tag|を参照。
5285                 タグファイルの内容によってはこれ以上の要素が存在することもある。
5286                 例: アクセス、実装、継承、シグネチャ。これらのフィールドについ
5287                 ての情報はctagsのドキュメントを参照。Cのソースにおいては、フィ
5288                 ールド"struct"、"class"、"enum"が現れることがある。これらは、
5289                 タグを含んでいるものの名前を示す。
5290
5291                 exコマンド'cmd'は検索パターンか、行番号か、行番号とバイト番号
5292                 のいずれかである。
5293
5294                 マッチするタグがない場合は空リストを返す。
5295
5296                 完全一致するタグを取得するには、{expr}にアンカー'^'と'$'をつけ
5297                 ること。タグ検索の正規表現についてより詳しいことは
5298                 |tag-regexp|を参照。
5299
5300                 Vimが使用するタグファイルについては|'tags'|を参照。様々な
5301                 ctagsによって生成されるタグファイルのフォーマットについては
5302                 |tags-file-format|を参照。
5303
5304                                                 *tempname()* *temp-file-name*
5305 tempname()
5306                 結果は文字列で、存在しないファイルのファイル名を示す。これはテ
5307                 ンポラリファイルの名前として使用可能である。少なくとも連続26回
5308                 の呼出しまでは違う名前を生成することが保証される。例: >
5309                         :let tmpfile = tempname()
5310                         :exe "redir > " . tmpfile
5311 <               Unix では、ファイルはプライベートなディレクトリに置かれる。
5312                 |tempfile|
5313                 MS-Windowsでは、'shellslash'がオンのときか'shellcmdflag'が'-'
5314                 で始まるときはスラッシュが使われる。
5315
5316 tolower({expr})                                         *tolower()*
5317                 引数の文字列の大文字を小文字に変換してできた文字列を返す(文字
5318                 列に|gu|を適用するのとちょうど同じ)。
5319
5320 toupper({expr})                                         *toupper()*
5321                 引数の文字列の小文字を大文字に変換してできた文字列を返す(文字
5322                 列に|gU|を適用するのとちょうど同じ)。
5323
5324 tr({src}, {fromstr}, {tostr})                           *tr()*
5325                 文字列{src}の中で、{fromstr}に含まれる全ての文字を{tostr}の対
5326                 応する文字で置き換えた文字列を返す。つまり、{fromstr}の最初の
5327                 文字が{tostr}の最初の文字に置き換えられる。2文字目以降も同様。
5328                 Unixのコマンド"tr"とちょうど同じである。
5329                 マルチバイト文字も正しく扱える。
5330
5331                 例: >
5332                         echo tr("hello there", "ht", "HT")
5333 <               戻り値は "Hello THere" となる。 >
5334                         echo tr("<blob>", "<>", "{}")
5335 <               戻り値は "{blob}" となる。
5336
5337 trunc({expr})                                                   *trunc()*
5338                 {expr} をゼロ方向に切りつめた整数を |Float| で返す。
5339                 {expr} は |Float| または |Number| に評価されなければならない。
5340                 例: >
5341                 Examples: >
5342                         echo trunc(1.456)
5343 <                       1.0  >
5344                         echo trunc(-5.456)
5345 <                       -5.0  >
5346                         echo trunc(4.0)
5347 <                       4.0
5348                 {|+float| 機能つきでコンパイルされたときのみ有効}
5349
5350                                                         *type()*
5351 type({expr})    {expr}の型を示す数値を返す:
5352                         数値:         0
5353                         文字列:        1
5354                         Funcref:    2
5355                         リスト:        3
5356                         辞書:         4
5357                         浮動小数点数:     5
5358                 マジックナンバーを使わずに、次のような使い方をすべきである: >
5359                         :if type(myvar) == type(0)
5360                         :if type(myvar) == type("")
5361                         :if type(myvar) == type(function("tr"))
5362                         :if type(myvar) == type([])
5363                         :if type(myvar) == type({})
5364                         :if type(myvar) == type(0.0)
5365
5366 values({dict})                                          *values()*
5367                 {dict}の全ての値からなるリスト|List|を返す。このリストの順序は
5368                 不定である。
5369
5370 virtcol({expr})                                         *virtcol()*
5371                 結果は数値で、{expr}で与えられるファイルの位置の、スクリーン上
5372                 での桁の位置を示す。返る値は、指定された位置にある文字の末尾が、
5373                 スクリーン座標(の桁)でどこに存在するかである。<Tab>(タブ文字)
5374                 が指定した位置にあった場合には、戻り値はそのタブの最後のカラム
5375                 (桁)位置になる。具体的に、'ts'が8に設定された状態で第1桁に
5376                 <Tab>があった場合、戻り値は8になる。
5377                 バイト位置については |col()| を使う。
5378                 {expr}の解釈の仕方については|col()|を参照。
5379                 'virtualedit'がオンのときは[lnum, col, off]というリストを指定
5380                 することもできる。"off"は文字の開始位置からのスクリーン座標で
5381                 のオフセットである。例えば、<Tab>の中の位置や、行の最後の文字
5382                 以降の位置を示すために使う。
5383                 現在のモードに対して仮想編集がオンのときは、行末を越えた位置が
5384                 返ってくることもある。|'virtualedit'|
5385                 可能な位置指定:
5386                     .       カーソルの位置
5387                     $       カーソル行の末尾(カーソル行に表示されている文字数
5388                             +1となる)
5389                     'x      マークxの位置(マークが設定されていない場合、0が返
5390                             る)
5391                 現在のファイルに対して設定されているマークだけが使用可能なこと
5392                 に注意。
5393                 例: >
5394   virtcol(".")      "foo^Lbar"の"^L"の位置にカーソル、戻り値5
5395   virtcol("$")     "foo^Lbar"に対し、戻り値9
5396   virtcol("'t")    "    there"の'h'に'tを設定、戻り値6
5397 <               最初の桁は1となる。エラーの場合は0が返る。
5398                 より高度な例(全ての行の長さの最大値を返す): >
5399                     echo max(map(range(1, line('$')), "virtcol([v:val, '$'])"))
5400
5401 visualmode([expr])                                              *visualmode()*
5402                 結果は文字列で、カレントバッファ内で最後に使われたビジュアルモー
5403                 ドを教えてくれる。初期状態では単に空文字列を返すだけだが、一度
5404                 でもビジュアルモードが使われた場合、その種類によって"v"か"V"か
5405                 "<CTRL-V>"(CTRL-Vの文字が1文字で)返される。これはそれぞれ文字
5406                 選択、行選択、ブロック選択を意味している。
5407                 例: >
5408                         exe "normal " . visualmode()
5409 <               これは最後に使われたのと同じビジュアルモードに入る。また、スク
5410                 リプトの動作を、最後に使われたビジュアルモードに応じて変更した
5411                 い場合にも便利だろう。
5412                 ビジュアルモードにいるときは |mode()| を使ってビジュアルモード
5413                 の種類を取得できる。(|:vmap| などの中などで)
5414
5415                                                         *non-zero-arg*
5416                 {expr}に0以外の数値か空文字列以外の文字列を指定した場合は、ビ
5417                 ジュアルモードがクリアされ、以前の値を返す。Note " "と"0"は空
5418                 文字列ではないことに注意。よってモードがクリアされる。リス
5419                 ト、辞書、浮動小数点数は数値でも文字列でもないのでモードはクリ
5420                 アされない。
5421
5422                                                         *winbufnr()*
5423 winbufnr({nr})  結果は数値で、{nr}番目のウィンドウに関連付けられているバッファ
5424                 の番号。{nr}が0の場合、現在のウィンドウに関連付けられている
5425                 バッファの番号が返る。{nr}で存在しないウィンドウを指定した場合
5426                 には-1が返る。
5427                 例: >
5428   :echo "The file in the current window is " . bufname(winbufnr(0))
5429 <
5430                                                         *wincol()*
5431 wincol()        結果は数値で、ウィンドウの中でカーソルがある位置の仮想桁番号を
5432                 表す。これはウィンドウの左側から数えたスクリーン上の桁である。
5433                 一番左の桁は1となる。
5434
5435 winheight({nr})                                         *winheight()*
5436                 結果は数値で、{nr}で示されるウィンドウの高さ(行数)を示す。{nr}
5437                 が0ならば、現在のウィンドウの高さが返る。{nr}というウィンドウ
5438                 が存在しない場合、-1が返る。存在しているウィンドウは、絶対に0
5439                 かそれ以上の高さを持っている。
5440                 例: >
5441   :echo "The current window has " . winheight(0) . " lines."
5442 <
5443
5444                                                         *winline()*
5445 winline()       結果は数値で、ウィンドウの最上行から数えた行番号を返す。ウィン
5446                 ドウでの最上行が1となる。
5447                 カーソルが移動するとファイルの表示が更新され、それによってスク
5448                 ロールが引き起こされることがある。
5449
5450                                                         *winnr()*
5451 winnr([{arg}])  結果は現在のウィンドウを示す数値。最上位のウィンドウは1であ
5452                 る。
5453                 省略可能な引数{arg}に"$"を設定すると、最後のウィンドウの番号が
5454                 返る(つまりウィンドウの個数)。
5455                 {arg}に"#"を設定すると、最後にアクセスしたウィンドウの番号を返
5456                 す(|CTRL-W_p|で移動するウィンドウと同じ)。
5457                 以前のウィンドウがない場合、またはそれが他のタブページにある場
5458                 合は0を返す。
5459                 この番号は|CTRL-W_w|と":wincmd w"で使える。|:wincmd|
5460                 |tabpagewinnr()|も参照。
5461
5462                                                         *winrestcmd()*
5463 winrestcmd()    現在のウィンドウサイズを復元するための一連の|:resize|コマンド
5464                 を返す。これが返すコマンドは、ウィンドウを開閉せず、カレントウィ
5465                 ンドウとカレントタブページが変更されていないときのみ正しく動作
5466                 する。
5467                 例: >
5468                         :let cmd = winrestcmd()
5469                         :call MessWithWindowSizes()
5470                         :exe cmd
5471 <
5472                                                         *winrestview()*
5473 winrestview({dict})
5474                 |winsaveview()|が返す辞書|Dictionary|を使ってカレントウィンド
5475                 ウの表示状態を復元する。
5476                 この値を手動で変更した場合、結果は予測できない。
5477                 ウィンドウサイズが変更されていると、結果は必ずしも元通りになら
5478                 ない。
5479
5480                                                         *winsaveview()*
5481 winsaveview()   カレントウィンドウの表示状態を復元するための情報を持つ辞書
5482                 |Dictionary|を返す。この表示状態を復元するには|winrestview()|
5483                 を使う。
5484                 マッピング内でジャンプして、元の表示状態を戻したいときに使われ
5485                 る。
5486                 折り畳み情報は保存しない。オプション'foldenable'によって一時的
5487                 に折り畳みをオフにし、移動中に折り畳みが開かれないようにするこ
5488                 と。
5489                 戻り値は以下のキーを持つ:
5490                         lnum            カーソルの行番号
5491                         col             カーソルの桁番号
5492                         coladd          カーソル位置の桁オフセット。
5493                                         'virtualedit'がオンのとき使われる。
5494                         curswant        垂直移動するときの桁
5495                         topline         ウィンドウの最上行
5496                         topfill         削除行。diffモードでのみ
5497                         leftcol         表示されている最初の桁
5498                         skipcol         スキップされている桁
5499                 Note オプションの値は保存されない。
5500
5501
5502 winwidth({nr})                                          *winwidth()*
5503                 結果は数値で、ウィンドウ{nr}の幅。{nr}が0のときはカレントウィ
5504                 ンドウの幅を返す。ウィンドウ{nr}が存在しないときは-1を返す。
5505                 ウィンドウは必ず0以上の幅を持つ。
5506                 例: >
5507   :echo "The current window has " . winwidth(0) . " columns."
5508   :if winwidth(0) <= 50
5509   :  exe "normal 50\<C-W>|"
5510   :endif
5511 <
5512                                                         *writefile()*
5513 writefile({list}, {fname} [, {binary}])
5514                 |List| {list}をファイル{fname}に書き込む。リストの各要素は改行
5515                 文字(NL)で区切られる。各要素は文字列か数値でなければならない。
5516                 {binary}が"b"のときはバイナリモードとなり、最後の要素の後にNL
5517                 が追加されない。最後の要素が空であると、ファイルの最後の行が
5518                 NLで終わるようになる。
5519                 NL文字はNUL文字に置換される。
5520                 CR文字を加えるには、{list}をwritefile()に渡す前に行わねばなら
5521                 ない。
5522                 既存のファイルは上書きされる(上書き可能ならば)。
5523                 書き込みが失敗したときは-1を返す。そうでなければ0を返す。ファ
5524                 イルを作成できないときや、書き込みが失敗したときはエラーメッセ
5525                 ージが表示される。
5526                 |readfile()|も参照。
5527                 バイト単位でファイルをコピーするには次のようにする: >
5528                         :let fl = readfile("foo", "b")
5529                         :call writefile(fl, "foocopy", "b")
5530 <
5531                                                         *feature-list*
5532 機能は大別して3つの系統に分けられる:
5533 1.  コンパイル時に|+feature-list|とした時にだけサポートされる機能。例: >
5534                 :if has("cindent")
5535 2.  ある状態の時にだけサポートされる機能。例: >
5536                 :if has("gui_running")
5537 <                                                       *has-patch*
5538 3.  適用済みパッチ。最初に|v:version|によってVimのバージョンを確認する。
5539     機能"patch123"はパッチ123が適用されていることを示す。例(バージョン6.2.148
5540     以降であることを確認する): >
5541         :if v:version > 602 || v:version == 602 && has("patch148")
5542 <   Note 148が適用されていても、147が抜けていることもありうるので注意。
5543
5544 all_builtin_terms       総ての組込みターミナルを有効にしてコンパイル
5545 amiga                   AMIGAバージョン
5546 arabic                  アラビア語をサポート |Arabic|
5547 arp                     ARPをサポート (Amiga)
5548 autocmd                 オートコマンドをサポート |autocommand|
5549 balloon_eval            |balloon-eval| をサポート
5550 balloon_multiline       複数行バルーンをサポート
5551 beos                    BeOSバージョン
5552 browse                  |:browse|をサポートし、browseが恐らく動作する
5553 builtin_terms           幾つかの組込みターミナルが有効
5554 byte_offset             'statusline'において'o'がサポートされる
5555 cindent                 'cindent'をサポート
5556 clientserver            リモート呼び出しをサポート |clientserver|
5557 clipboard               'clipboard'をサポート
5558 cmdline_compl           |cmdline-completion| コマンドライン補完をサポート
5559 cmdline_hist            |cmdline-history| コマンドライン履歴をサポート
5560 cmdline_info            'showcmd'と'ruler'をサポート
5561 comments                |'comments'|をサポート
5562 cryptv                  暗号化をサポート |encryption|
5563 cscope                  |cscope|をサポート
5564 compatible              Vi互換度を非常に高めてコンパイルされている
5565 debug                   デバッグバージョンである
5566 dialog_con              コンソールダイアログのサポート
5567 dialog_gui              GUIダイアログのサポート
5568 diff                    Compiled with |vimdiff| and 'diff' support.
5569 digraphs                digraphsをサポート
5570 dnd                     レジスタ"~をサポート |quote_~|.
5571 dos32                   32ビットDOSバージョン (DJGPP)
5572 dos16                   16ビットDOSバージョン
5573 ebcdic                  EBCDIC文字集合のマシン用
5574 emacs_tags              Emacs式のタグファイルをサポート
5575 eval                    式評価をサポート。もちろん常に真。
5576 ex_extra                拡張exコマンドをサポート |+ex_extra|.
5577 extra_search            |'incsearch'|と|'hlsearch'|をサポート
5578 farsi                   |farsi|をサポート
5579 file_in_path            |gf|と|<cfile>|をサポート
5580 filterpipe              'shelltemp'がオフのとき、シェルの読み込み・書き込み・
5581                         フィルタコマンドにパイプを使う。
5582 find_in_path            includeファイル内の検索をサポート |+find_in_path|
5583 float                   浮動小数点数 |Float| サポート
5584 fname_case              ファイル名の大文字小文字が区別される(Amiga,MS-DOS,
5585                         そしてWindowsでは区別されないので偽)
5586 folding                 |folding| 折り畳みをサポート
5587 footer                  GUIのフッタをサポート |gui-footer|
5588 fork                    system()の代わりにfork()/exec()を用いている
5589 gettext                 翻訳メッセージをサポート |multi-lang|
5590 gui                     GUIが有効である
5591 gui_athena              AthenaのGUIが有効である
5592 gui_gtk                 GTK+のGUIが有効である
5593 gui_gnome               Gnomeサポート(gui_gtkも定義される)
5594 gui_gtk2                GTK+ 2のGUIが有効である (gui_gtkも定義される)
5595 gui_mac                 マッキントッシュのGUIが有効である
5596 gui_motif               MotifのGUIが有効である
5597 gui_photon              PhotonのGUIが有効である
5598 gui_win32               Win32のGUIが有効である
5599 gui_win32s              Win32sのGUIが有効である (Windows 3.1)
5600 gui_running             VimがGUIモードで起動している、もしくは間もなくする
5601 hangul_input            ハングル入力サポート
5602 iconv                   iconv()をサポート
5603 insert_expand           インサートモード時にCTRL-Xの展開がサポートされる
5604 jumplist                |jumplist| をサポート
5605 keymap                  'keymap' をサポート
5606 langmap                 'langmap'サポート
5607 libcall                 |libcall()| をサポート
5608 linebreak               'linebreak', 'breakat'そして'showbreak'をサポート
5609 lispindent              lisp式のインデントをサポート
5610 listcmds                バッファリスト用のコマンド|:files|と引数リスト用のコマ
5611                         ンド|arglist|をサポート
5612 localmap                ローカルなマッピングと短縮入力をサポート|:map-local|
5613 mac                     マッキントッシュバージョン
5614 macunix                 Unixファイル用のマッキントッシュバージョン(OS-X)
5615 menu                    |:menu|をサポート
5616 mksession               |:mksession|をサポート
5617 modify_fname            ファイル名変換子をサポート |filename-modifiers|
5618 mouse                   マウスをサポート
5619 mouseshape              'mouseshape'をサポート
5620 mouse_dec               DECのターミナルマウスをサポート
5621 mouse_gpm               gpmをサポート (Linuxのコンソールマウス)
5622 mouse_netterm           nettermのマウスをサポート
5623 mouse_pterm             qnx ptermのマウスをサポート
5624 mouse_sysmouse          sysmouse (*BSD コンソールマウス)をサポート
5625 mouse_xterm             xtermのマウスをサポート
5626 multi_byte              'encoding' をサポート
5627 multi_byte_encoding     'encoding' がマルチバイトエンコーディングになる
5628 multi_byte_ime          IMEによる入力をサポート
5629 multi_lang              複数言語をサポート
5630 mzscheme                MzSchemeインターフェイスをサポート |mzscheme|.
5631 netbeans_intg           |netbeans|をサポート
5632 netbeans_enabled        |netbeans|をサポートし、現在使用している
5633 ole                     Win32にてOLEオートメーションをサポート
5634 os2                     OS/2バージョン
5635 osfiletype              osfiletypesをサポート |+osfiletype|
5636 path_extra              'path'と'tags'の上方・下方検索をサポート
5637 perl                    Perlインターフェイスをサポート
5638 postscript              PostScriptファイルの印刷をサポート
5639 python                  Pythonインターフェイスをサポート
5640 qnx                     QNXバージョン
5641 quickfix                |quickfix|をサポート
5642 reltime                 |reltime()|をサポート
5643 rightleft               'rightleft'をサポート
5644 ruby                    Rubyインターフェイスをサポート
5645 scrollbind              'scrollbind'をサポート
5646 showcmd                 'showcmd'をサポート
5647 signs                   |:sign|をサポート
5648 smartindent             'smartindent'をサポート
5649 sniff                   SniFFインターフェイスをサポート
5650 startuptime             |--startuptime| をサポート
5651 statusline              'statusline', 'rulerformat'そして'titlestring'と
5652                         'iconstring'の特殊フォーマットをサポート
5653 sun_workshop            Sun |workshop|をサポート
5654 spell                   スペルチェックをサポート |spell|
5655 syntax                  構文ハイライトをサポート
5656 syntax_items            現在のバッファに有効なシンタックスが設定されている
5657 system                  fork()/exec()の代わりにsystem()が使用されている
5658 tag_binary              タグファイル内のバイナリサーチ |tag-binary-search|
5659 tag_old_static          旧式の静的tagsをサポート |tag-old-static|
5660 tag_any_white           タグファイル内の空白文字をサポート |tag-any-white|.
5661 tcl                     TCLインターフェースをサポート
5662 terminfo                termcapの代わりにterminfoをサポート
5663 termresponse            |t_RV|と|v:termresponse|をサポート
5664 textobjects             |text-objects|をサポート
5665 tgetent                 tgetentをサポート。termcapかterminfoファイルが使用可能
5666 title                   ウィンドウタイトルをサポート |'title'|.
5667 toolbar                 |gui-toolbar|をサポート
5668 unix                    UNIXバージョン
5669 user_commands           ユーザ定義コマンドをサポート
5670 viminfo                 viminfoをサポート
5671 vim_starting            Vimの初期化プロセス中は真となる
5672 vertsplit               ウィンドウの垂直分割をサポート |:vsplit|
5673 virtualedit             オプション'virtualedit'をサポート
5674 visual                  ビジュアルモードをサポート
5675 visualextra             拡張Visualモードをサポート |blockwise-operators|
5676 vms                     VMSバージョン
5677 vreplace                コマンド|gR|と|gr|をサポート
5678 wildignore              オプション'wildignore'をサポート
5679 wildmenu                オプション'wildmenu'を指定してコンパイル
5680 windows                 複数ウィンドウをサポート
5681 winaltkeys              オプション'winaltkeys'を指定してコンパイル
5682 win16                   Win16バージョン(Windows 3.1)
5683 win32                   Win32バージョン(Windows 95/98/ME/NT/2000/XP)
5684 win64                   Win64バージョン(Windows 64 bit)
5685 win32unix               Win32バージョン。Unixファイルを使用 (Cygwin)
5686 win95                   Win32バージョン。MS-Windows 95/98/ME用。
5687 writebackup             オプション'writebackup'が起動時にonになる
5688 xfontset                X fontsetをサポート |xfontset|
5689 xim                     XIMをサポート |xim|
5690 xsmp                    Xセッションマネージメントをサポート
5691 xsmp_interact           対話的Xセッションマネージメントをサポート
5692 xterm_clipboard         xtermのクリップボードサポート
5693 xterm_save              xtermのスクリーンの保存復帰をサポート
5694 x11                     X11をサポート
5695
5696                                                         *string-match*
5697 文字列内でのパターンマッチング
5698
5699 |pattern|で説明されている正規表現パターンは通常、バッファ内の行に対してマッチ
5700 を検索するために使われる。文字列内でマッチを見つけるために使うときも、ほとんど
5701 は同じように動作する。違いは、文字列が1つの行であるかのように扱われる事である。
5702 文字列が文字"\n"だけを含むとき、これは改行とはみなされない。この"\n"はパターン
5703 内の"\n"や"."にマッチする。例: >
5704         :let a = "aaaa\nxxxx"
5705         :echo matchstr(a, "..\n..")
5706         aa
5707         xx
5708         :echo matchstr(a, "a.x")
5709         a
5710         x
5711
5712 "^"は文字列の最初の文字でだけマッチし、"$"は最後の文字でだけマッチすることに注
5713 意。"\n"の前後にはマッチしない。
5714
5715 ==============================================================================
5716 5. 関数定義                                         *user-functions*
5717
5718 ユーザは自分で新しい関数を定義することができる。その関数は組込み関数とまったく
5719 同じように呼び出せる。関数は一連のExコマンドを実行する。ノーマルモードコマンド
5720 はコマンド|:normal|によって実行できる。
5721
5722 関数名は組込み関数との混同を避ける為、大文字で始まらなければならない。他のスク
5723 リプトで同じ関数名を使用してしまうことを避ける為に、露骨に短い名前は避けるべき
5724 である。関数名を例えば"HTMLcolor()"のように、スクリプトの名前から始めるという
5725 のは良い習慣である。
5726
5727 波括弧変数というものもある(|curly-braces-names|を参照)。また、オートロード
5728 |autoload|機構を使うと、関数が呼ばれたときだけ定義することができる。
5729
5730                                                         *local-function*
5731 スクリプトローカルな関数の名前は"s:"で始めなければならない。スクリプトローカル
5732 な関数は、そのスクリプトの中の関数から、またはそのスクリプト内で定義されたユー
5733 ザ定義コマンド、オートコマンドからしか呼ぶことができない。そのスクリプト内で定
5734 義されたマッピングにより呼ぶこともできるが、スクリプトの外部でマッピングが展開
5735 された場合は"s:"の代わりに|<SID>|をつけなければならない。
5736
5737                                         *:fu* *:function* *E128* *E129* *E123*
5738 :fu[nction]             総ての関数と、その引数を表示する。
5739
5740 :fu[nction] {name}      関数{name}の定義を表示する。
5741                         {name}は辞書|Dictionary|の要素の|Funcref|であってもよ
5742                         い: >
5743                                 :function dict.init
5744
5745 :fu[nction] /{pattern}  {pattern}にマッチする名前の関数を表示する。"File"で終
5746                         わる関数を全て表示する例: >
5747                                 :function /File$
5748 <
5749                                                         *:function-verbose*
5750 'verbose'が 0 でないとき、これらのコマンドで関数を表示すると、それがどこで定義
5751 されたかも表示する。例: >
5752
5753     :verbose function SetFileTypeSH
5754         function SetFileTypeSH(name)
5755             Last set from /usr/share/vim/vim-7.0/filetype.vim
5756 <
5757 より詳しくは|:verbose-cmd|を参照。
5758
5759                                                         *E124* *E125*
5760 :fu[nction][!] {name}([arguments]) [range] [abort] [dict]
5761                         {name}という名前で新しい関数を定義する。関数名はアル
5762                         ファベットと数字と'_'からなり、通常の関数はアルファベッ
5763                         トの大文字、スクリプトローカル関数は"s:"で始まらなけれ
5764                         ばならない。
5765
5766                         {name}は辞書|Dictionary|の要素の|Funcref|であってもよ
5767                         い: >
5768                                 :function dict.init(arg)
5769 <                       "dict"は既に定義されている辞書でなければならない。その
5770                         要素"init"がまだ存在しないならば追加される。存在する場
5771                         合は、既存の関数を上書きするためには[!]をつけなければ
5772                         ならない。この値は番号つきの関数を指す|Funcref|である。
5773                         この関数は|Funcref|を通してのみ呼ぶことができ、そこへの
5774                         参照がなくなると削除される。
5775                                                                 *E127* *E122*
5776                         この名前で定義される関数が既に定義済みで[!]が使用され
5777                         なかった場合、エラーとなる。[!]が使用されていれば、そ
5778                         れまで存在していた関数は、速やかに新しいものへ置換えら
5779                         れる。
5780
5781                         引数{arguments}については|function-argument|を参照。
5782
5783                                                 *a:firstline* *a:lastline*
5784                         引数[range]を追加した場合、関数は「範囲」を管理するこ
5785                         とができる。「範囲」は"a:firstline"と"a:lastline"に
5786                         よって渡される。[range]がなかった場合、":{range}call"
5787                         が「範囲」を指定されて実行されると、1行1行について、カー
5788                         ソルをその行の先頭に置いた状態で関数を呼び出すことにな
5789                         る。|function-range-example|を参照。
5790
5791                         引数[abort]を追加すると、関数の実行中にエラーに遭遇し
5792                         次第、即関数は中断される。
5793
5794                         引数[dict]を追加すると、この関数は辞書|Dictionary|の要
5795                         素を通してしか呼べなくなる。そしてその辞書にローカル変
5796                         数"self"が定義される。|Dictionary-function|を参照。
5797
5798                                                 *function-search-undo*
5799                         関数の実行によって、最後に使用されたサーチパターン、及
5800                         びredoコマンドの"."の内容は変更されない。したがって、
5801                         関数内で|:nohlsearch| を行っても、関数から戻ると検索結
5802                         果のハイライトが元に戻ることになる。
5803
5804                                         *:endf* *:endfunction* *E126* *E193*
5805 :endf[unction]          関数定義の終了。このコマンド1つで1行とすること。他のコ
5806                         マンドをいっしょに書いてはならない。
5807
5808                                         *:delf* *:delfunction* *E130* *E131*
5809 :delf[unction] {name}   関数{name}を削除する。
5810                         {name}は辞書|Dictionary|の要素の|Funcref|であってもよ
5811                         い: >
5812                                 :delfunc dict.init
5813 <                       この例は"dict"から要素"init"を削除する。この関数への参
5814                         照がなくなると、関数は削除される。
5815                                                         *:retu* *:return* *E133*
5816 :retu[rn] [expr]        関数から戻る。"[expr]"が与えられた場合、それは評価され
5817                         関数の戻り値として呼出し側に渡される。"[expr]"が与えら
5818                         れない場合、数値0が呼出し側に渡される。
5819                         関数内に実行されない命令があるかどうかはチェックされな
5820                         いことに留意すること。つまり、たとえ":return"命令の後
5821                         に何か命令があったとしても、警告も何も与えられない。
5822
5823                         |:try|と|:finally|の間で":return"が実行された場合、
5824                         ":finally"から対応する|:endtry|までのコマンドがまず実
5825                         行される。":try"がネストしている場合、それらの全てに対
5826                         してこのプロセスが適用される。そして最も外側の
5827                         ":endtry"にて関数を抜ける。
5828
5829                                                 *function-argument* *a:var*
5830 引数は、与えられた名前によって定義される。関数のなかでは"a:name"("a:"を引数に
5831 接頭)のようにして参照することができる。
5832                                         *a:0* *a:1* *a:000* *E740* *...*
5833 引数はカンマで区切ることで、最大20まで与えることができる。最後の引数を"..."に
5834 することで、可変長の引数を使用できる。関数の中では"a:1"や"a:2"のようにして可変
5835 長の引数にアクセスできる。"a:0"は可変長引数が幾つあるかを示している(0であるこ
5836 と、つまり引数がそれ以上ないこともある)。"a:000"は全引数を持つリスト|List|を示
5837 している。Note "a:1"は"a:000[0]"と同じである。
5838                                                                 *E742*
5839 a: のスコープとこの変数は固定されており、変更できない。
5840 しかしリスト|List|か辞書|Dictionary|の場合は、その要素を変更できる。よって関数
5841 にリスト|List|を渡し、そこに要素を追加させることができる。関数にリストや辞書を
5842 変更させたくない場合は|:lockvar|を使うこと。
5843
5844 "..."が使われていない時は、引数の数は名前付きの引数の個数を示す。"..."を使った
5845 時には引数の数は大きくなるだろう。
5846
5847 関数を引数無しで定義することも可能である。その時でも()は付けなければならない。
5848 関数の本体は、宣言の次の行から始まり、対応する|:endfunction|までになる。関数の
5849 中で別の関数を定義することも可能である。
5850
5851
5852                                                         *local-variables*
5853 関数の中で変数を使うこともできる。これらは関数から戻ると消滅するローカル変数と
5854 して振舞う。グローバル変数にアクセスするためには"g:"を付ける必要がある。
5855
5856 例: >
5857   :function Table(title, ...)
5858   :  echohl Title
5859   :  echo a:title
5860   :  echohl None
5861   :  echo a:0 . " items:"
5862   :  for s in a:000
5863   :    echon ' ' . s
5864   :  endfor
5865   :endfunction
5866
5867 この関数は次のように呼ぶことが出きる: >
5868   let lines = Table("Table", "line1", "line2")
5869   let lines = Table("Empty Table")
5870
5871 一つ以上の値を返したい場合には、グローバル変数の名前を渡すようにする: >
5872   :function Compute(n1, n2)
5873   :  if a:n2 == 0
5874   :    return ["fail", 0]
5875   :  endif
5876   :  return ["ok", a:n1 / a:n2]
5877   :endfunction
5878
5879 この関数は次のように呼ぶことができる: >
5880   :let [success, div] = Compute(102, 6)
5881   :if success == "ok"
5882   :  echo div
5883   :endif
5884 <
5885
5886                                                 *:cal* *:call* *E107* *E117*
5887 :[range]cal[l] {name}([arguments])
5888                 関数を呼び出す。関数の名前と引数は|:function|によって指定され
5889                 るものである。引数は最大20まで使用可能。戻り値は破棄される。
5890                 「範囲」を受け付ける関数に「範囲」を指定しなかった場合、関数は
5891                 カーソルの現在位置について一度だけ呼び出される。
5892                 「範囲」を受け付けない関数に「範囲」を指定した場合、その範囲の
5893                 一行ずつについて関数が呼び出される。その時カーソルは当該行の先
5894                 頭に設定される。カーソルは「範囲」の最下行の左端になる(恐らく
5895                 最後の関数呼出しの結果、動いた先である)。引数は各呼出しについ
5896                 て繰り返し評価される。それは次の例で確かめることができる:
5897                                                 *function-range-example*  >
5898         :function Mynumber(arg)
5899         :  echo line(".") . " " . a:arg
5900         :endfunction
5901         :1,5call Mynumber(getline("."))
5902 <
5903                 "a:firstline"と"a:lastline"はとにかく定義されるので、「範囲」
5904                 の最初や最後で何か違った事をするのにも用いることができる。
5905
5906                 「範囲」自身を扱っている関数の例: >
5907
5908         :function Cont() range
5909         :  execute (a:firstline + 1) . "," . a:lastline . 's/^/\t\\ '
5910         :endfunction
5911         :4,8call Cont()
5912 <
5913                 この関数は「範囲」の最初の行を除いた総ての行の先頭に、継続のた
5914                 めの文字"\"を挿入する。
5915
5916                 この関数の戻り値からさらに間接参照が行われる場合、その参照先に
5917                 は範囲が渡されない。例: >
5918         :4,8call GetDict().method()
5919 <               GetDict()には範囲が渡されるが、method()には渡されない。
5920
5921                                                                 *E132*
5922 関数の再帰的な使用はオプション|'maxfuncdepth'|によって制限することができる。
5923
5924 自動的に読み込まれる関数 ~
5925                                                         *autoload-functions*
5926 たくさんの関数または巨大な関数を使うときは、それらが使用されたときだけ自動的に
5927 定義されるようにすることができる。これには2つの方法がある: オートコマンドによ
5928 る方法と、'runtimepath'内の"autoload"ディレクトリによる方法である。
5929
5930
5931 オートコマンドを使う方法 ~
5932
5933 これはユーザマニュアルのセクション|41.14|で説明されている。
5934
5935 オートコマンドは、長いVimスクリプトファイルのプラグインに対して有用である。自動
5936 コマンドを定義し、すぐに|:finish|でそのスクリプトを抜ける。こうするとVimの起動
5937 が速くなる。その後オートコマンドにより|:finish|コマンドをスキップする変数を定義
5938 し、そのファイルが再び読み込まれる。
5939
5940 定義すべき関数名にマッチするパターンを指定してオートコマンドイベント
5941 FuncUndefinedを使う。例: >
5942
5943         :au FuncUndefined BufNet* source ~/vim/bufnetfuncs.vim
5944
5945 ファイル"~/vim/bufnetfuncs.vim"は"BufNet"で始まる関数を定義しなければならない。
5946 |FuncUndefined|も参照。
5947
5948
5949 オートロードスクリプトの使い方 ~
5950                                                         *autoload* *E746*
5951 これはユーザマニュアルのセクション|41.15|で説明されている。
5952
5953 "autoload"ディレクトリのスクリプトを使う方法はより簡単である。しかし完全に正し
5954 いファイル名を使う必要がある。オートロードされる関数は次のような名前を持つ: >
5955
5956         :call filename#funcname()
5957
5958 このような関数が呼ばれ、それがまだ定義されていなかった場合、Vimは'runtimepath'
5959 内の"autoload"ディレクトリから"filename.vim"というスクリプトファイルを探す。
5960 例えば"~/.vim/autoload/filename.vim"のように。そしてこのファイルは次のような関
5961 数を定義していなければならない: >
5962
5963         function filename#funcname()
5964            echo "Done!"
5965         endfunction
5966
5967 このファイル名と関数の # の前の部分は完全に一致しなければならない。そして定義
5968 された関数は呼ばれた関数と完全に同じ名前でなければならない。
5969
5970 サブディレクトリを使うこともできる。関数名の中の # はパスのセパレータのように
5971 解釈される。つまり、次の関数を呼ぶと: >
5972
5973         :call foo#bar#func()
5974
5975 Vimは'runtimepath'からファイル"autoload/foo/bar.vim"を探す。
5976
5977 これはまだ定義されていない変数を参照するときにも使える: >
5978
5979         :let l = foo#bar#lvar
5980
5981 しかしこのオートロードスクリプトがすでに読み込まれている場合、未知の変数があっ
5982 てもこのスクリプトは再読み込みされない。
5983
5984 この変数に値を代入するときは、何も特別なことはない。この方法は、オートロードス
5985 クリプトが読み込まれる前に設定を渡すために使うことができる: >
5986
5987         :let foo#bar#toggle = 1
5988         :call foo#bar#func()
5989
5990 オートロードスクリプト内で定義されるはずの関数を呼んだがスクリプト内で関数が定
5991 義されなかった場合、その関数を呼ぶたびにそのスクリプトがsourceされる。そして毎
5992 回エラーメッセージが表示される。
5993
5994 また、2つのスクリプト間で、互いに自分が定義される前に相手を呼ぶような関数があ
5995 ると、これは動作しない。
5996 トップレベルでオートロード機能を使うのは避けること。
5997
5998 Hint: たくさんのファイルからなるスクリプトを配布する場合には、|vimball|ユーティ
5999 リティを使うとそれらをまとめることができる。ユーザマニュアルの
6000 |distribute-script|も参照。
6001
6002 ==============================================================================
6003 6. 波括弧変数                                                *curly-braces-names*
6004
6005 変数を使える文脈ではいつでも「波括弧」変数を使うことができる。これは有効な変数
6006 名であり、次のように、1個以上の式を波括弧{}で囲む: >
6007         my_{adjective}_variable
6008
6009 Vimはこれを見つけると、まず波括弧の中の式を評価し、その値をもとの位置に置きか
6010 え、全体を変数名として再解釈する。よって上の例では、変数"adjective"に"noisy"が
6011 代入されていたとすると、この変数は"my_noisy_variable"となる。あるいは、
6012 "adjective"に"quiet"が代入されていたとすれば"my_quiet_variable"となる。
6013
6014 これの応用の1つは、オプション値によって支配される変数の集合を作ることである。
6015 例えば次の文 >
6016         echo my_{&background}_message
6017
6018 は現在の'background'の値に応じて"my_dark_message"か"my_light_message"の中身を
6019 表示する。
6020
6021 波括弧を複数使うこともできる: >
6022         echo my_{adverb}_{adjective}_message
6023 ネストさせることもできる: >
6024         echo my_{ad{end_of_word}}_message
6025 ここで"end_of_word"は"verb"か"jective"のどちらかである。
6026
6027 しかし、波括弧の中の式を評価した結果が有効な変数名とならなければならない。
6028 つまり、次は無効である: >
6029         :let foo='a + b'
6030         :echo c{foo}d
6031 というのは、展開の結果が"ca + bd"となるからで、これは有効な名前ではない。
6032
6033                                                 *curly-braces-function-names*
6034 同様の方法で評価した名前により関数を定義したり呼び出したりできる。
6035 例: >
6036         :let func_end='whizz'
6037         :call my_func_{func_end}(parameter)
6038
6039 この例は関数"my_func_whizz(parameter)"を呼びだす。
6040
6041 ==============================================================================
6042 7. コマンド                                         *expression-commands*
6043
6044 :let {var-name} = {expr1}                               *:let*
6045                         内部変数{var-name}に式{expr1}の結果をセットする。変数
6046                         の型は{expr1}によって決定される。{var-name}という変数
6047                         がまだ存在しない場合、新たに作成される。
6048
6049 :let {var-name}[{idx}] = {expr1}                        *E689*
6050                         リストの要素に式{expr1}の結果をセットする。{var-name}
6051                         はリストを参照し、{idx}はそのリストの有効なインデック
6052                         スでなければならない。ネストしたリストに対してはインデ
6053                         ックスを繰り返すことができる。
6054                         このコマンドはリストに要素を追加するためには使えない。
6055                         文字列の i バイト目をセットするためにも使えない。それ
6056                         には次のようにする: >
6057                                 :let var = var[0:2] . 'X' . var[4:]
6058 <
6059
6060                                                         *E711* *E719*
6061 :let {var-name}[{idx1}:{idx2}] = {expr1}                *E708* *E709* *E710*
6062                         リスト|List|の一部を式{expr}の値で置き換える。{expr}の
6063                         値は正しい個数の要素を持つリストでなければならない。
6064                         {idx1}を省略すると0となる。
6065                         {idx2}を省略するとリストの末尾となる。
6066                         指定された範囲の一部がリストの末尾を越える場合、要素が
6067                         追加される。
6068
6069                                         *:let+=* *:let-=* *:let.=* *E734*
6070 :let {var} += {expr1}   ":let {var} = {var} + {expr1}"と同様。
6071 :let {var} -= {expr1}   ":let {var} = {var} - {expr1}"と同様。
6072 :let {var} .= {expr1}   ":let {var} = {var} . {expr1}"と同様。
6073                         {var}がセットされていないときや、{var}と{expr1}の型が
6074                         演算子に合わないときは失敗する。
6075
6076
6077 :let ${env-name} = {expr1}                      *:let-environment* *:let-$*
6078                         環境変数{env-name}に式{expr1}の結果をセットする。型は
6079                         常に文字列。
6080 :let ${env-name} .= {expr1}
6081                         環境変数{env-name}に{expr1}を付け加える。その環境変数
6082                         が存在しないときは"="と同様にはたらく。
6083
6084 :let @{reg-name} = {expr1}                      *:let-register* *:let-@*
6085                         式{expr1}の結果をレジスタ{reg-name}に書きこむ。
6086                         {reg-name}は単一の文字でかつ、書きこむことのできるレジ
6087                         スタでなければならない(|registers|を参照)。"@@"は名前
6088                         無しレジスタとして使用でき、"@/"はサーチパターンとして
6089                         使用できる。
6090                         {expr1}の結果が<CR>か<NL>で終了していた場合、レジスタ
6091                         は行単位で設定され、そうでなければキャラクタ単位で設定
6092                         される。
6093                         次のコマンドにより最後に検索したパターンをクリアするこ
6094                         とができる: >
6095                                 :let @/ = ""
6096 <                       これは空文字列を検索するのとは異なる。空文字列を検索す
6097                         ると、いたるところでマッチする。
6098
6099 :let @{reg-name} .= {expr1}
6100                         レジスタ{reg-name}に{expr1}を付け加える。このレジスタ
6101                         が空のときは、そこに{expr1}をセットする。
6102
6103 :let &{option-name} = {expr1}                   *:let-option* *:let-&*
6104                         オプション{option-name}に式{expr}の値をセットする。文
6105                         字列や数値の値はそのオプションの型に変換される。
6106                         ウィンドウやバッファについてローカルなオプションに対し
6107                         ては、その効果は|:set|コマンドを使ったときと同様で、ロー
6108                         カルな値とグローバルな値の両方が変更される。
6109                         例: >
6110                                 :let &path = &path . ',/usr/local/include'
6111
6112 :let &{option-name} .= {expr1}
6113                         文字列のオプションの場合: その値に{expr}を付け加える。
6114                         |:set+=|とは違い、コンマを挿入しない。
6115
6116 :let &{option-name} += {expr1}
6117 :let &{option-name} -= {expr1}
6118                         数値または切替のオプションの場合: {expr1}を足す・引く。
6119
6120 :let &l:{option-name} = {expr1}
6121 :let &l:{option-name} .= {expr1}
6122 :let &l:{option-name} += {expr1}
6123 :let &l:{option-name} -= {expr1}
6124                         上と同様だが、オプションのローカルな値だけをセットする
6125                         (ローカルな値があるならば)。|:setlocal|と同様にはたら
6126                         く。
6127
6128 :let &g:{option-name} = {expr1}
6129 :let &g:{option-name} .= {expr1}
6130 :let &g:{option-name} += {expr1}
6131 :let &g:{option-name} -= {expr1}
6132                         上と同様だが、オプションのグローバルな値だけをセットす
6133                         る(グローバルな値があるならば)。|:setglobal|と同様には
6134                         たらく。
6135
6136 :let [{name1}, {name2}, ...] = {expr1}          *:let-unpack* *E687* *E688*
6137                         {expr1}の値はリスト|List|でなければならない。そのリス
6138                         トの最初の要素が{name1}に代入され、2番目の要素が
6139                         {name2}に代入される。以下同様。
6140                         nameの個数がリスト|List|の要素の個数に一致しなければな
6141                         らない。
6142                         前述のように各nameは":let"コマンドの要素の1つになるこ
6143                         とができる。
6144                         例: >
6145                                 :let [s, item] = GetItem(s)
6146 <                       詳細: 最初に{expr1}が評価され、それから順番に代入が行
6147                         われる。{name2}が{name1}に依存するかどうかは問題になる。
6148                         例: >
6149                                 :let x = [0, 1]
6150                                 :let i = 0
6151                                 :let [i, x[i]] = [1, 2]
6152                                 :echo x
6153 <                       子の結果は[0, 2]となる。
6154
6155 :let [{name1}, {name2}, ...] .= {expr1}
6156 :let [{name1}, {name2}, ...] += {expr1}
6157 :let [{name1}, {name2}, ...] -= {expr1}
6158                         上と同様だが、リスト|List|の各要素に対し連結・足し算・
6159                         引き算を行う。
6160
6161 :let [{name}, ..., ; {lastname}] = {expr1}
6162                         |:let-unpack|と同様だが、リスト|List|の要素数がnamesの
6163                         数より多くてもよい。余った要素のリストが{lastname}に代
6164                         入される。要素の余りがないとき{lastname}は空リストにな
6165                         る。
6166                         例: >
6167                                 :let [a, b; rest] = ["aval", "bval", 3, 4]
6168 <
6169 :let [{name}, ..., ; {lastname}] .= {expr1}
6170 :let [{name}, ..., ; {lastname}] += {expr1}
6171 :let [{name}, ..., ; {lastname}] -= {expr1}
6172                         上と同様だが、リスト|List|の各要素に対して連結・足し算
6173                         ・引き算を行う。
6174                                                         *E106*
6175 :let {var-name} ..      変数{var-name}の値を一覧表示する。変数の名前を複数指定
6176                         することができる。以下の特別な名前が認識される:        *E738*
6177                           g:    グローバル変数
6178                           b:    バッファローカル変数
6179                           w:    ウィンドウローカル変数
6180                           t:    タブページローカル変数
6181                           s:    スクリプトローカル変数
6182                           l:    関数ローカル変数
6183                           v:    Vimの変数
6184
6185 :let                    全変数の値を一覧表示する。値の前に変数の型が示される:
6186                             <nothing>   文字列
6187                                 #       数値
6188                                 *       Funcref
6189
6190
6191 :unl[et][!] {name} ...                          *:unlet* *:unl* *E108* *E795*
6192                         内部変数{name}を削除する。複数の変数名を指定すると、そ
6193                         れらが全て削除される。名前はリスト|List|や辞書
6194                         |Dictionary|の要素でもよい。
6195                         [!]をつけると存在しない変数に対するエラーメッセージを
6196                         表示しない。
6197                         リスト|List|から1個以上の要素を削除することができる: >
6198                                 :unlet list[3]    " 4番目の要素を削除
6199                                 :unlet list[3:]   " 4番目から最後までの要素を
6200                                                     削除
6201 <                       辞書からは一度に1個の要素を削除することができる: >
6202                                 :unlet dict['two']
6203                                 :unlet dict.two
6204                         グローバル変数とスクリプトローカル変数をクリーンアップ
6205                         するために特に便利である(これらはスクリプト終了時に検
6206                         出されない)。関数ローカルな関数は、その関数から抜ける
6207                         ときに自動的に削除される。
6208
6209 :lockv[ar][!] [depth] {name} ...                        *:lockvar* *:lockv*
6210                         内部変数{name}をロックする。ロックすると、それ以降変更
6211                         ができなくなる(アンロックするまで)。
6212                         ロックされた変数を削除することはできる: >
6213                                 :lockvar v
6214                                 :let v = 'asdf'         " 失敗!
6215                                 :unlet v
6216 <                                                       *E741*
6217                         ロックされた変数を変更しようとするとエラーメッセージ
6218                         "E741: Value of {name} is locked"が表示される。
6219
6220                         [depth]はリスト|List|や辞書|Dictionary|をロックすると
6221                         きに意味がある。どれだけ深くロックするかを指定する:
6222                                 1       リストや辞書それ自身をロックする。要素
6223                                         を追加したり削除はできないが、要素の値
6224                                         を変えることはできる。
6225                                 2       要素の値もロックする。その要素がリスト
6226                                         や辞書である場合、その中の要素の追加や
6227                                         削除はできないが、値の変更はできる。
6228                                 3       2と同様だが、リスト・辞書内のリスト・
6229                                         辞書に対してもあてはまる。1レベル深い。
6230                         [depth]の既定値は2であり、{name}がリストまたは辞書であ
6231                         る場合、その値は変更できない。
6232                                                                 *E743*
6233                         深さを無限にするには[!]を使い、[depth]を省略する。しか
6234                         しループを捕捉するために深さの最大値は100に設定されて
6235                         いる。
6236
6237                         Note 2つの変数が同じリスト|List|を参照している場合、片
6238                         方の変数をロックすると、もう一方の変数を介してアクセス
6239                         した場合もロックされている。
6240                         例: >
6241                                 :let l = [0, 1, 2, 3]
6242                                 :let cl = l
6243                                 :lockvar l
6244                                 :let cl[1] = 99         " 代入できない!
6245 <
6246                         これを回避するにはリストのコピーを作るとよい。
6247                         |deepcopy()|を参照。
6248
6249
6250 :unlo[ckvar][!] [depth] {name} ...                      *:unlockvar* *:unlo*
6251                         内部変数{name}をアンロックする。|:lockvar|の逆を行う。
6252
6253
6254 :if {expr1}                                             *:if* *:endif* *:en*
6255 :en[dif]                {expr1}が非ゼロと評価された場合に、対応する":else"か
6256                         ":endif"までの命令を実行する。
6257
6258                         バージョン4.5から5.0まで間のVimは、":if"と":endif"の間
6259                         の総てのExコマンドは無視する。この2つのコマンドは将来
6260                         の拡張性を、下位互換と同時に提供するためのものである。
6261                         ネスティング(入れ子)が可能である。":else"や":elseif"は
6262                         無視され、"else"部分は一切実行されないことに注意。
6263
6264                         あなたはこれを、旧バージョンとの互換性を保ったまま使用
6265                         することができる: >
6266                                 :if version >= 500
6267                                 :  version-5-specific-commands
6268                                 :endif
6269 <                       しかしそれでも"endif"を見つけるために後続のコマンドを
6270                         パースする必要がある。古いVimで新しいコマンドを使うと
6271                         問題が起こることがある。例えば":silent"が":substitute"
6272                         コマンドと認識されるなど。その場合には、":execute"を使
6273                         うと問題を避けることができる: >
6274                                 :if version >= 600
6275                                 :  execute "silent 1,$delete"
6276                                 :endif
6277 <
6278                         NOTE: ":append"と":insert"コマンドは":if"と":endif"の
6279                         間では正しく動かない。
6280
6281                                                 *:else* *:el* *E581* *E583*
6282 :el[se]                 対応する":if"ブロックが実行されなかった場合には、これ
6283                         に対応する":else"か":endif"までのコマンドが実行され
6284                         る。
6285
6286                                         *:elseif* *:elsei* *E582* *E584*
6287 :elsei[f] {expr1}       ":else" ":if"の省略形。":endif"を付け加える(入れ子にす
6288                         る)手間を省くことができる。
6289
6290 :wh[ile] {expr1}                        *:while* *:endwhile* *:wh* *:endw*
6291                                                 *E170* *E585* *E588* *E733*
6292 :endw[hile]             {expr1}が非ゼロとして評価される間、":while"と
6293                         ":endwhile"の間のコマンドを繰り返し実行する。
6294                         ループの内側でエラーが生じた場合、endwhileの直後から実
6295                         行が再開される。
6296                         例: >
6297                                 :let lnum = 1
6298                                 :while lnum <= line("$")
6299                                    :call FixLine(lnum)
6300                                    :let lnum = lnum + 1
6301                                 :endwhile
6302 <
6303                 注意: ":append"や":insert"コマンドは":while"ループの内側では正
6304                 しく動かない。
6305
6306 :for {var} in {list}                                    *:for* *E690* *E732*
6307 :endfo[r]                                               *:endfo* *:endfor*
6308                         {list}の各要素に対し、":for"と":endfor"の間のコマンド
6309                         を繰り返す。変数{var}に各要素の値がセットされる。
6310                         ループの内側のコマンドでエラーが検出されたときは
6311                         "endfor"の後から実行が継続される。
6312                         ループの内側で{list}を変更するとどの要素が使われるかに
6313                         影響を与える。それを望まない場合はコピーを作ること: >
6314                                 :for item in copy(mylist)
6315 <                       コピーを作らないと、Vimは現在の要素に対してコマンドを
6316                         実行する前に、リストの次の要素への参照を保存する。その
6317                         ため副作用なしに現在の要素を削除することができる。それ
6318                         以降の要素を変更すると、それが見つからなくなる。つまり
6319                         以下の例は動作する(リストを空にする非効率な方法): >
6320                                 for item in mylist
6321                                    call remove(mylist, 0)
6322                                 endfor
6323 <                       Note リストを並べ替える(例えばsort()やreverse()で)と予
6324                         期しない結果になることがある。
6325                         Note {var}の型が変わってしまうのを避けるために、リスト
6326                         の各要素の型は同じでなければならない。ループの末尾でこ
6327                         の変数をunletすれば要素の型が同一でなくてもよくなる: >
6328                                 for item in ["foo", ["bar"]]
6329                                    echo item
6330                                    unlet item  " これがないと E706 になる
6331                                 endfor
6332
6333 :for [{var1}, {var2}, ...] in {listlist}
6334 :endfo[r]
6335                         上の":for"と同様だが、{listlist}の各要素がリストでなけ
6336                         ればならない点が異なる。そのリストの各要素が{var1},
6337                         {var2}などに代入される。例: >
6338                                 :for [lnum, col] in [[1, 3], [2, 5], [3, 8]]
6339                                    :echo getline(lnum)[col]
6340                                 :endfor
6341 <
6342                                                 *:continue* *:con* *E586*
6343 :con[tinue]             ":while"または":for"ループの内側で使われたときは、その
6344                         ループの開始位置まで戻る。
6345                         ループの内側の|:try|と|:finally|の間で使われた場合、
6346                         |:finally|から|:endtry|までの間のコマンドがまず実行さ
6347                         れる。ループの内側で":try"がネストしている場合、全ての
6348                         ":try"に対してこのプロセスが適用される。最も外側の
6349                         ":endtry"の後ループの開始位置まで戻る。
6350
6351                                                 *:break* *:brea* *E587*
6352 :brea[k]                ":while"または":for"ループの内側で使われたときは、対応
6353                         する":endwhile"または":endfor"の後のコマンドまでスキッ
6354                         プする。
6355                         ループの内側の|:try|と|:finally|の間で使われた場合、
6356                         |:finally|から|:endtry|までの間のコマンドがまず実行さ
6357                         れる。ループの内側で":try"がネストしている場合、全ての
6358                         ":try"に対してこのプロセスが適用される。最も外側の
6359                         ":endtry"の後ループの後までジャンプする。
6360
6361 :try                            *:try* *:endt* *:endtry* *E600* *E601* *E602*
6362 :endt[ry]               ":try"と":endtry"の間のコマンド(":source"コマンド、関
6363                         数呼び出し、オートコマンド実行を含めた全てのコマンド実
6364                         行)のエラー制御を変更する。
6365
6366                         エラーや割り込みが検出された場合、後に|:finally|コマン
6367                         ドがあるならば、":finally"の後から実行が継続される。そ
6368                         うでければ、または":endtry"に達した後は次の動的に囲ん
6369                         でいる":try"に対応する":finally"などが探される。その後
6370                         スクリプトは実行を停止する。(関数定義に引数"abort"がつ
6371                         いているかどうかは関係ない)
6372                         例: >
6373                 :try | edit too much | finally | echo "cleanup" | endtry
6374                 :echo "impossible"      " 実行されない。上のコマンドにより
6375                                         " スクリプトは停止する。
6376 <
6377                         さらに、(動的に)":try"と":endtry"の内側にあるエラーや
6378                         割り込みは例外に変換される。そしてそれは|:throw|コマン
6379                         ドによって投げたときと同様に捕捉できる(|:catch|を参照)。
6380                         この場合はスクリプトの実行は停止しない。
6381
6382                         割り込み例外には"Vim:Interrupt"という値が使われる。
6383                         Vimコマンドにおけるエラーは"Vim({command}):{errmsg}"と
6384                         いう形式の値に変換される。その他のエラーは
6385                         "Vim:{errmsg}"という形式のエラーに変換される。ここで
6386                         {command}はコマンドの完全な名前であり、{errmsg}はその
6387                         例外が捕捉されなかった場合に表示されるメッセージで、常
6388                         にエラー番号で始まる。
6389                         例: >
6390                 :try | sleep 100 | catch /^Vim:Interrupt$/ | endtry
6391                 :try | edit | catch /^Vim(edit):E\d\+/ | echo "error" | endtry
6392 <
6393                                         *:cat* *:catch* *E603* *E604* *E605*
6394 :cat[ch] /{pattern}/    {pattern}にマッチする例外が発生し、より前の|:catch|
6395                         で捕捉されなかった場合、このコマンドから次の|:catch|,
6396                         |:finally|, |:endtry|までのコマンドが実行される。その
6397                         ような例外が発生しなかった場合、そのコマンドはスキップ
6398                         される。
6399                         {pattern}が省略された場合は全てのエラーが捕捉される。
6400                         例: >
6401                 :catch /^Vim:Interrupt$/        " 割り込み (CTRL-C) を捕捉
6402                 :catch /^Vim\%((\a\+)\)\=:E/    " 全Vimエラーを捕捉
6403                 :catch /^Vim\%((\a\+)\)\=:/     " 例外と割り込みを捕捉
6404                 :catch /^Vim(write):/           " :writeにおける全エラーを捕捉
6405                 :catch /^Vim\%((\a\+)\)\=:E123/ " エラーE123を捕捉
6406                 :catch /my-exception/           " ユーザ定義例外を捕捉
6407                 :catch /.*/                     " 全てを捕捉
6408                 :catch                          " /.*/と同じ
6409 <
6410                         {pattern}を囲むのに/以外の文字を使うことができる。ただ
6411                         しその文字は特別な意味(例: '|'や'"'など)を持っていては
6412                         ならず、{pattern}の内側に現れてはならない。
6413                         NOTE: エラーメッセージの本文によって":catch"することは
6414                         確実ではない。メッセージはロケールによって異なるからで
6415                         ある。
6416
6417                                         *:fina* *:finally* *E606* *E607*
6418 :fina[lly]              |:try|と":finally"の間を抜ける前に必ず、このコマンドか
6419                         ら対応する|:endtry|の間のコマンドが実行される。つまり
6420                         正常に進んだ場合、|:continue|, |:break|, |:finish|,
6421                         |:return|を使った場合、エラー・割り込み・例外が発生し
6422                         た場合(|:throw|を参照)のいずれの場合でも。
6423
6424                                                         *:th* *:throw* *E608*
6425 :th[row] {expr1}        {expr1}を評価し、例外として投げる。|:try|と|:catch|の
6426                         間で":throw"が使われた場合、{expr1}にマッチする最初の
6427                         |:catch|までのコマンドはスキップされる。そのような
6428                         ":catch"がない場合、または":catch"と|:finally|の間で
6429                         ":throw"が使われた場合、":finally"から|:endtry|までの
6430                         コマンドが実行される。":throw"が":finally"の後で実行さ
6431                         れた場合、":endtry"までのコマンドはスキップされる。
6432                         ":endtry"において、動的に囲んでいる次の":try"(これは関
6433                         数呼び出しやスクリプトsourceも含めて探される)から対応
6434                         する":catch"までに対しこのプロセスが再び適用される。例
6435                         外が捕捉されない場合、コマンドの処理は終了する。
6436                         例: >
6437                 :try | throw "oops" | catch /^oo/ | echo "caught" | endtry
6438 <
6439                                                         *:ec* *:echo*
6440 :ec[ho] {expr1} ..      各{expr1}をスペースで区切って表示する。最初の{expr1}の
6441                         表示は、常に新しい行から始まる。
6442                         |:comment|も参照。
6443                         改行が必要な場合 "\n" を使用する。カーソルを第1桁に
6444                         持って行くには "\r" を使用する。
6445                         色強調を行うにはコマンド|:echohl|を使用する。
6446                         コメント文を同じ行に続けることはできない。
6447                         例: >
6448                 :echo "the value of 'shell' is" &shell
6449 <                                                       *:echo-redraw*
6450                         このコマンドの後、再描画を行うと表示したメッセージが消
6451                         えてしまう。Vim は一連のコマンドが完了するまで再描画を
6452                         後回しにするため、この現象は頻繁に発生する。例えば、
6453                         ":echo" より前に実行したコマンドが後で再描画を引き起こ
6454                         し、メッセージが消えてしまうということがある(再描画は
6455                         しばしばユーザが何か入力するまで後回しにされる)。この
6456                         問題を避けるには、|:redraw| を使って強制的に再描画する
6457                         こと。例: >
6458                 :new | redraw | echo "there is a new window"
6459 <
6460
6461                                                         *:echon*
6462 :echon {expr1} ..       改行を付けずに、{expr1}を表示する。|:comment|も参照。
6463                         色強調を行うにはコマンド|:echohl|を使用する。
6464                         コメント文を同じ行に続けることはできない。
6465                         例: >
6466                                 :echon "the value of 'shell' is " &shell
6467 <
6468                         Vimコマンドの":echo"と、外部のシェルコマンドである
6469                         ":!echo"との違いに注意: >
6470                 :!echo %                --> filename
6471 <                       ":!"の引数は展開される。|:_%|を参照。 >
6472                 :!echo "%"              --> filename or "filename"
6473 <                       前の例のように働く。ダブルクォートが表示されるかどうか
6474                         は、使用している'shell'に依存する。 >
6475                 :echo %                 --> 何も表示されない
6476 <                       '%'は式として不当な文字である。 >
6477                 :echo "%"               --> %
6478 <                       単に文字'%'を表示する。 >
6479                 :echo expand("%")       --> filename
6480 <                       '%'を展開するために関数expand()を呼び出している。
6481
6482                                                         *:echoh* *:echohl*
6483 :echoh[l] {name}        次の|:echo|, |:echon|, |:echomsg|"コマンドから、ハイラ
6484                         イトグループ{name}を適用する。|input()|のプロンプトに
6485                         対しても適用される。例: >
6486                 :echohl WarningMsg | echo "Don't panic!" | echohl None
6487 <                       使用した後にはグループを"None"に戻すことを忘れないよう
6488                         に。さもないとそれ以降のechoの表示総てがハイライトされ
6489                         てしまう。
6490
6491                                                         *:echom* *:echomsg*
6492 :echom[sg] {expr1} ..   式を本当のメッセージとして表示し、そのメッセージをメッ
6493                         セージ履歴|message-history|に保存する。
6494                         |:echo|コマンド同様に、引数の間にスペースが挿入される。
6495                         しかし印字不可能な文字は解釈されずに表示される。
6496                         |:echo|とはかなり異なり、むしろ|:execute|に近い方法で
6497                         解析がされる。なんらかを表示する前に、まず最初に全ての
6498                         式が評価し、連結する。式を評価した値は数値か文字列でな
6499                         ければならない。辞書やリストはエラーとなる。
6500                         強調を行うには|:echohl|コマンドを使う。
6501                         例: >
6502                 :echomsg "It's a Zizzer Zazzer Zuzz, as you can plainly see."
6503 <                       画面を再描画したときメッセージが消去されてしまうのを避
6504                         ける方法については|:echo-redraw|を参照。
6505                                                         *:echoe* *:echoerr*
6506 :echoe[rr] {expr1} ..   式をエラーメッセージとして表示し、そのメッセージを
6507                         メッセージ履歴|message-history|に保存する。スクリプト
6508                         や関数の中で使用されたときは行番号が付け加えられる。
6509                         |:echo|コマンドと同様に引数の間にスペースが挿入される。
6510                         try条件文の中で使用されたときは、このメッセージがエラ
6511                         ー例外として投げられる。(|try-echoerr|を参照)
6512                         例: >
6513                 :echoerr "This script just failed!"
6514 <
6515                         単にメッセージを強調させたい場合には|:echohl|を使うこ
6516                         と。ビープを鳴らしたいときには次のようにする: >
6517                 :exe "normal \<Esc>"
6518 <
6519                                                         *:exe* *:execute*
6520 :exe[cute] {expr1} ..   {expr1}の評価結果の文字列をExコマンドとして実行する。
6521                         複数の引数は連結され、間にスペースが挿入される。
6522                         {expr1}は処理されたコマンドとして扱われ、コマンドライ
6523                         ン編集用のキーは認識されない。
6524                         コメント文を同じ行に続けることはできない。
6525                         例: >
6526                 :execute "buffer " nextbuf
6527                 :execute "normal " count . "w"
6528 <
6529                         ":execute"は'|'を受けつけないコマンドに、次のコマンドを
6530                         続けて実行させるのにも使用できる。例: >
6531                 :execute '!ls' | echo "theend"
6532 <                       (訳注:普通の使い方では":!ls"の後には'|'を使って、Exコ
6533                         マンドを続けることはできない)
6534                         また":execute"は、Vimスクリプト内でコマンド":normal"の
6535                         引数に制御文字を書くことを避けるために役に立つ。 >
6536                 :execute "normal ixxx\<Esc>"
6537 <                       これで<Esc>文字を表す。|expr-string|を参照。
6538
6539                         ファイル名の中の特殊文字を正しくエスケープするように
6540                         注意すること。Vim コマンドに与えるファイル名をエス
6541                         ケープするには |fnameescape()| を使う。|:!| コマンドに
6542                         与えるときは |shellescape()| を使う。
6543                         例: >
6544                 :execute "e " . fnameescape(filename)
6545                 :execute "!ls " . shellescape(expand('%:h'), 1)
6546 <
6547                         注意:executeに渡す文字列としては、"while"や"if"系のコ
6548                         マンドが始まったり終ったりするだけのようなものは不適格
6549                         である。よって次のような例は認められない: >
6550                 :execute 'while i > 5'
6551                 :execute 'echo "test" | break'
6552 <
6553                         文字列の中に完全な"while"や"if"コマンドが含まれること
6554                         が求められる: >
6555                 :execute 'while i < 5 | echo i | let i = i + 1 | endwhile'
6556 <
6557
6558                                                         *:exe-comment*
6559                         ":execute"や":echo"そして":echon"は、同一行に直接コメ
6560                         ントを続けることはできない。何故ならそれらのコマンドに
6561                         とって'"'は文字列の始まりに見えてしまうからである。し
6562                         かし'|'の後にコメントを書くことは可能である。例: >
6563                 :echo "foo" | "this is a comment
6564
6565 ==============================================================================
6566 8. 例外処理                                 *exception-handling*
6567
6568 Vimスクリプト言語は例外処理機構を備えている。この節では例外処理をどのように行
6569 うかについて説明する。
6570
6571 例外はエラー発生時や割り込み発生時にVimによって投げられる。それについては
6572 |catch-errors|と|catch-interrupt|を参照。ユーザはコマンド|:throw|によって明示
6573 的に例外を投げることができる。|throw-catch|を参照。
6574
6575
6576 TRY 条件文                                 *try-conditionals*
6577
6578 例外を捕捉したり、例外を引き金として後始末のコードを実行することができる。try
6579 条件文を使う事によってcatch節(これが例外を捕捉する)やfinally節(後始末のために
6580 実行される)を指定する事ができる。
6581 try条件文はコマンド|:try|によって始まり、対応するコマンド|:endtry|によって終了
6582 する。その間でコマンド|:catch|によりcatch節を定めたり、コマンド|:finally|によ
6583 ってfinally節を定めることができる。catch節は1個もなかったり、複数個あってもよ
6584 い。しかしfinally節は1個までしか持てない。finally節の後にcatch節があってはなら
6585 ない。catch節とfinally節の前の部分はtryブロックと呼ばれる。
6586
6587      :try
6588      :  ...
6589      :  ...                             try ブロック
6590      :  ...
6591      :catch /{pattern}/
6592      :  ...
6593      :  ...                             catch 節
6594      :  ...
6595      :catch /{pattern}/
6596      :  ...
6597      :  ...                             catch 節
6598      :  ...
6599      :finally
6600      :  ...
6601      :  ...                             finally 節
6602      :  ...
6603      :endtry
6604
6605 try条件文により、コードから発生する例外を監視したり、適切な対応を取ることができる。
6606 tryブロック内で発生した例外は捕捉される。tryブロックとcatch節内で発生した例外
6607 は捕捉され、後始末が行われる。
6608 tryブロックの実行中に例外が発生しなかった場合は、制御は(もしあれば)finally節に
6609 移動する。その実行後に、スクリプトは":endtry"の後の行から実行を継続する。
6610 tryブロックの実行中に例外が発生した場合は、tryブロックの残りの行はスキップされる。
6611 例外はコマンド":catch"の引数として指定された正規表現に照合される。最初にマッチ
6612 した":catch"の後のcatch節が実行される。他のcatch節は実行されない。catch節は次
6613 に":catch", ":finally", ":endtry"が現れたところで終了する(どれでもよい)。
6614 ":endtry"に達すると、スクリプトは次の行から通常通り実行が続けられる。
6615 発生した例外が、コマンド":catch"で指定されたどの正規表現にもマッチしないとき、
6616 その例外はそのtry条件文で捕捉されず、どのcatch節も実行されない。finally節があ
6617 るならば実行される。finally節の実行中は例外は後回しにされ、":endtry"のときに実
6618 行される。そして":endtry"の後のコマンドは実行されず、例外は他のどこかで捕捉さ
6619 れる。|try-nesting|を参照。
6620 catch節の実行中に新たな例外が発生した場合は、そのcatch節の残りの行は実行されな
6621 い。新しい例外は同じtry条件文のどの":catch"コマンドの正規表現にも照合されず、
6622 どのcatch節も実行されない。しかしfinally節があるならばそこが実行され、その間そ
6623 の例外は保留される。":endtry"の後のコマンドは実行されない。新しい例外は他のど
6624 こかで捕捉される。|try-nesting|を参照。
6625 finally節の実行中に例外が発生した場合は、そのfinally節の残りの行は実行されない。
6626 tryブロックやそのcatch節のどこかで例外が発生してからそのfinally節が実行されて
6627 いた場合は、元の(保留されていた)例外は破棄される。":endtry"の後のコマンドは実
6628 行されない。finally節で発生した例外は伝播し、他のどこかで捕捉される。
6629 |try-nesting|を参照。
6630
6631 完全なtry条件文を囲む":while"ループ内で、tryブロックやcatch節において":break"
6632 や":continue"が実行されたときもfinally節が実行される。
6633 また、関数の中やsourceされたスクリプト中で、tryブロックやtry条件文のcatch節に
6634 おいて":return"や":finish"が実行されたときもfinally節が実行される。finally節の
6635 実行中は":break", ":continue", ":return", ":finish"は保留され、":endtry"に達し
6636 たとき再開される。しかしこれらは、そのfinally節内で例外が発生したときは破棄さ
6637 れる。
6638 完全なtry条件節を囲む":while"ループ内での":break"や":continue"、またはfinally
6639 節内で":return"や":finish"に出会ったときは、finally節の残りはスキップされ、通
6640 常通り":break", "continue", ":return", "finish"が実行される。もしそのfinally節
6641 の前に、tryブロックやcatch節内で例外が発生したり、":break", ":continue",
6642 ":return", ":finally"が行われていた場合は、それらの保留されていた例外やコマン
6643 ドは破棄される。
6644
6645 例として |throw-catch| と |try-finally| を参照。
6646
6647
6648 try条件文のネスト                                      *try-nesting*
6649
6650 try条件文は任意にネストされられる。つまり、try条件文のtryブロック・catch節・
6651 finally節のなかに別の完全なtry条件文を書くことができる。内側のtry条件文がtryブ
6652 ロックで発生した例外を捕捉しなかったときや、catch節・finally節で新たな例外が発
6653 生したときは、外側のtry条件文がそのルールにしたがって例外を捕捉する。内側の
6654 try条件文が外側の条件文のtryブロックの中にある場合はcatch節が判定されるが、そ
6655 うでない場合はfinally節のみが実行される。これはネストの仕方には関係ない。つま
6656 り、内側のtry条件文が直接外側のtry条件文に含まれていてもよいし、外側がスクリプ
6657 トをsourceしたり、内側のtry条件文を含む関数を呼び出していてもよい。
6658
6659 有効なtry条件文のどれも例外を捕捉しなかったときは、それらのfinally節が実行され
6660 る。その後、スクリプトの実行は停止する。":throw"コマンドにより明示的に投げられ
6661 た例外が捕捉されなかった場合は、エラーメッセージが表示される。Vimによって暗黙
6662 的に投げられたエラーや割り込み例外については、通常通りエラーメッセージや割り込
6663 みメッセージが表示される。
6664
6665 例として |throw-catch| を参照。
6666
6667
6668 例外処理コードの検査                                      *except-examine*
6669
6670 例外処理のコードはトリッキーになりがちである。何が起こっているか知りたいときは
6671 スクリプトファイルをsourceするときに'verbose'を13に設定するか、コマンド修飾子
6672 ":13verbose"を使う。すると例外が発生・破棄・捕捉・完了したときには表示されるよ
6673 うになる。冗長度のレベルを14異常にすると、finally節において保留されているもの
6674 も表示されるようになる。この情報はデバッグモードでも表示される
6675 (|debug-scripts|を参照)。
6676
6677
6678 例外の生成と捕捉                                        *throw-catch*
6679
6680 任意の数値や文字列を例外として投げることができる。コマンド|:throw|を使い、投げ
6681 られる値を引数に渡す: >
6682         :throw 4711
6683         :throw "string"
6684 <                                                       *throw-expression*
6685 式を引数に指定することもできる。まずその式が評価され、その結果が投げられる: >
6686         :throw 4705 + strlen("string")
6687         :throw strpart("strings", 0, 6)
6688
6689 ":throw"コマンドの引数を評価している最中に例外が発生することもありうる。その例
6690 外が捕捉されない限り、その式の評価は破棄される。
6691 よって、その":throw"コマンドは例外を投げることができない。
6692    例: >
6693
6694         :function! Foo(arg)
6695         :  try
6696         :    throw a:arg
6697         :  catch /foo/
6698         :  endtry
6699         :  return 1
6700         :endfunction
6701         :
6702         :function! Bar()
6703         :  echo "in Bar"
6704         :  return 4710
6705         :endfunction
6706         :
6707         :throw Foo("arrgh") + Bar()
6708
6709 この例を実行すると"arrgh"が投げられ、Bar()が実行されないため"in Bar"は表示され
6710 ない。しかし次のようにすると >
6711         :throw Foo("foo") + Bar()
6712 "in Bar"を表示し、4711を投げる。
6713
6714 式を引数として受け取る他のコマンドでも、式の評価中に捕捉されない例外が発生する
6715 とコマンドが破棄される。そして例外はそのコマンドを呼び出した位置へ伝播する。
6716    例: >
6717
6718         :if Foo("arrgh")
6719         :  echo "then"
6720         :else
6721         :  echo "else"
6722         :endif
6723
6724 この例で、"then"と"else"のどちらも表示されない。
6725
6726                                                         *catch-order*
6727 例外は、1個以上の|:catch|コマンドを持つtry条件文で捕捉することができる。これに
6728 ついては|try-conditionals|を参照。各":catch"コマンドで捕捉される値は、引数にて
6729 正規表現で指定できる。マッチする例外が捕捉されると、その後に続くcatch節が実行
6730 される。
6731    例: >
6732
6733         :function! Foo(value)
6734         :  try
6735         :    throw a:value
6736         :  catch /^\d\+$/
6737         :    echo "Number thrown"
6738         :  catch /.*/
6739         :    echo "String thrown"
6740         :  endtry
6741         :endfunction
6742         :
6743         :call Foo(0x1267)
6744         :call Foo('string')
6745
6746 最初のFoo()の呼び出しは"Number thrown"を表示し、2番目の呼び出しは"String
6747 thrown"を表示する。例外は、順番に":catch"コマンドに照合される。最初にマッチし
6748 たcatch節だけが実行される。そのため、より限定的な":catch"を先に書くべきである。
6749 次の順序で書くと無意味になってしまう: >
6750
6751         :  catch /.*/
6752         :    echo "String thrown"
6753         :  catch /^\d\+$/
6754         :    echo "Number thrown"
6755
6756 最初の":catch"は常にマッチするため、2番目のcatch節は決して実行されない。
6757
6758                                                         *throw-variables*
6759 一般的な正規表現により例外を捕捉した場合、その正確な値には変数|v:exception|に
6760 よりアクセスできる: >
6761
6762         :  catch /^\d\+$/
6763         :    echo "Number thrown.  Value is" v:exception
6764
6765 また、どこで例外が発生したかも知りたいだろう。これは|v:throwpoint|に保持されて
6766 いる。Note "v:exception"と"v:throwpoint"は最も直近に捕捉された例外に対し、それ
6767 が終了するまで有効である。
6768    例: >
6769
6770         :function! Caught()
6771         :  if v:exception != ""
6772         :    echo 'Caught "' . v:exception . '" in ' . v:throwpoint
6773         :  else
6774         :    echo 'Nothing caught'
6775         :  endif
6776         :endfunction
6777         :
6778         :function! Foo()
6779         :  try
6780         :    try
6781         :      try
6782         :        throw 4711
6783         :      finally
6784         :        call Caught()
6785         :      endtry
6786         :    catch /.*/
6787         :      call Caught()
6788         :      throw "oops"
6789         :    endtry
6790         :  catch /.*/
6791         :    call Caught()
6792         :  finally
6793         :    call Caught()
6794         :  endtry
6795         :endfunction
6796         :
6797         :call Foo()
6798
6799 上の例は次のように表示する  >
6800
6801         Nothing caught
6802         Caught "4711" in function Foo, line 4
6803         Caught "oops" in function Foo, line 10
6804         Nothing caught
6805
6806 実用的な例:  次のコマンド":LineNumber"は、それが呼び出されたスクリプトや関数中
6807 の行番号を表示する: >
6808
6809         :function! LineNumber()
6810         :    return substitute(v:throwpoint, '.*\D\(\d\+\).*', '\1', "")
6811         :endfunction
6812         :command! LineNumber try | throw "" | catch | echo LineNumber() | endtry
6813 <
6814                                                         *try-nested*
6815 try条件文によって捕捉されないはそれを囲むtry条件文によって捕捉することができる
6816 : >
6817
6818         :try
6819         :  try
6820         :    throw "foo"
6821         :  catch /foobar/
6822         :    echo "foobar"
6823         :  finally
6824         :    echo "inner finally"
6825         :  endtry
6826         :catch /foo/
6827         :  echo "foo"
6828         :endtry
6829
6830 内側のtry条件文はこの例外を捕捉せず、finally節が実行されるだけである。そしてこ
6831 の例外は外側のtry条件文で捕捉される。この例を実行すると"inner finally"と"foo"
6832 が表示される。
6833
6834                                                         *throw-from-catch*
6835 例外を捕捉した後、新しい例外を投げて他のcatch節で捕捉させることができる: >
6836
6837         :function! Foo()
6838         :  throw "foo"
6839         :endfunction
6840         :
6841         :function! Bar()
6842         :  try
6843         :    call Foo()
6844         :  catch /foo/
6845         :    echo "Caught foo, throw bar"
6846         :    throw "bar"
6847         :  endtry
6848         :endfunction
6849         :
6850         :try
6851         :  call Bar()
6852         :catch /.*/
6853         :  echo "Caught" v:exception
6854         :endtry
6855
6856 これを実行すると"Caught foo, throw bar"と"Caught bar"が表示される。
6857
6858                                                         *rethrow*
6859 Vimスクリプト言語には本物のrethrowはないが、代わりに"v:exception"を使うことが
6860 できる: >
6861
6862         :function! Bar()
6863         :  try
6864         :    call Foo()
6865         :  catch /.*/
6866         :    echo "Rethrow" v:exception
6867         :    throw v:exception
6868         :  endtry
6869         :endfunction
6870 <                                                       *try-echoerr*
6871 Note この方法はVimのエラーや割り込み例外を"rethrow"するためには使えない。Vimの
6872 内部例外を偽装することはできないからである。それを行おうとするとエラー例外が発
6873 生する。その状況を表す自分自身の例外を投げるべきである。独自のエラー例外値を含
6874 むVimのエラー例外を発生させたい場合には、コマンド|:echoerr|を使うことができる: >
6875
6876         :try
6877         :  try
6878         :    asdf
6879         :  catch /.*/
6880         :    echoerr v:exception
6881         :  endtry
6882         :catch /.*/
6883         :  echo v:exception
6884         :endtry
6885
6886 このコードを実行すると次が表示される
6887
6888         Vim(echoerr):Vim:E492: Not an editor command:   asdf ~
6889
6890
6891 後始末処理                                           *try-finally*
6892
6893 しばしばスクリプト中でグローバルな設定を変更し、最後に元の設定を復元することが
6894 ある。しかしユーザがCTRL-Cを押してスクリプトを中断すると、設定が一貫しない状態
6895 になってしまう。スクリプトの開発段階においても、エラーが発生したり、明示的に例
6896 外を投げたが捕捉されなかった場合に、同じことが起こりうる。この問題は、try条件
6897 文を使ってfinally節で設定を復元することで解決できる。finally節は、通常の制御フ
6898 ロー・エラー時・明示的な":throw"時・割り込み時に実行されることが保証されている。
6899 (Note try条件文の内側で発生したエラーと割り込みは例外に変換される。これらが捕
6900 捉されなかったときには、finally節の実行の後にスクリプトの実行が停止する。)
6901 例: >
6902
6903         :try
6904         :  let s:saved_ts = &ts
6905         :  set ts=17
6906         :
6907         :  " Do the hard work here.
6908         :
6909         :finally
6910         :  let &ts = s:saved_ts
6911         :  unlet s:saved_ts
6912         :endtry
6913
6914 関数やスクリプトの一部でグローバルな設定を変更し、その関数・スクリプトの失敗時・
6915 通常終了時に設定を復元する必要があるときは、必ず局所的にこの手法を使うべきであ
6916 る。
6917
6918                                                         *break-finally*
6919 ":continue", ":break", ":return", ":finish"などによってtryブロックやcatch節を
6920 抜けるときも後始末処理が働く。
6921    例: >
6922
6923         :let first = 1
6924         :while 1
6925         :  try
6926         :    if first
6927         :      echo "first"
6928         :      let first = 0
6929         :      continue
6930         :    else
6931         :      throw "second"
6932         :    endif
6933         :  catch /.*/
6934         :    echo v:exception
6935         :    break
6936         :  finally
6937         :    echo "cleanup"
6938         :  endtry
6939         :  echo "still in while"
6940         :endwhile
6941         :echo "end"
6942
6943 上の例を実行すると"first", "cleanup", "second", "cleanup", "end"と表示される:
6944 >
6945         :function! Foo()
6946         :  try
6947         :    return 4711
6948         :  finally
6949         :    echo "cleanup\n"
6950         :  endtry
6951         :  echo "Foo still active"
6952         :endfunction
6953         :
6954         :echo Foo() "returned by Foo"
6955
6956 上の例を実行すると"cleanup"と"4711 returned by Foo"が表示される。finally節に余
6957 計な":return"を書く必要はない。(そうすると戻り値が上書きされてしまう)
6958
6959                                                         *except-from-finally*
6960 finally節で":continue", ":break", ":return", ":finish", ":throw"を使うことは可
6961 能である。しかしそうするとtry条件文の後始末を破棄してしまうことになるので推奨
6962 されていない。しかし、当然、finally節の中で割り込みとエラー例外が発生すること
6963 はありうる。
6964 finally節におけるエラーにより、割り込みが正しく動作しなくなる例: >
6965
6966         :try
6967         :  try
6968         :    echo "Press CTRL-C for interrupt"
6969         :    while 1
6970         :    endwhile
6971         :  finally
6972         :    unlet novar
6973         :  endtry
6974         :catch /novar/
6975         :endtry
6976         :echo "Script still running"
6977         :sleep 1
6978
6979 失敗する可能性のあるコマンドをfinally節に書く必要があるときは、それらのコマン
6980 ドにより発生するエラーを捕捉したり無視したりすることについて考えること。
6981 |catch-errors| と |ignore-errors| を参照。
6982
6983
6984 エラーを変更する                                        *catch-errors*
6985
6986 特定のエラーを捕捉するには、監視したいコードをtryブロックに入れ、そのエラーメ
6987 ッセージに対するcatch節を加えるだけでよい。try条件節が存在すると全てのエラーは
6988 例外に変換される。そのため、メッセージはまったく表示されず、|v:errmsg|は設定さ
6989 れない。":catch"コマンドに対する正しい正規表現を作るには、エラー例外のフォーマ
6990 ットがどのようなものか知っていなければならない。
6991    エラー例外は次のフォーマットを持つ: >
6992
6993         Vim({cmdname}):{errmsg}
6994 または >
6995         Vim:{errmsg}
6996
6997 {cmdname}は失敗したコマンド名である。2番目の形式はコマンド名が不明のとき用いら
6998 れる。{errmsg}は、そのエラーがtry条件文の外で発生したときに通常表示されるエラー
6999 メッセージである。エラーメッセージは必ず大文字の"E"で始まり、その後に2,3桁のエ
7000 ラー番号、コロン、スペースが続く。
7001
7002 例:
7003
7004 次のコマンドを実行すると、 >
7005         :unlet novar
7006 通常次のエラーメッセージが表示される  >
7007         E108: No such variable: "novar"
7008 これはtry条件文の中では例外に変換される >
7009         Vim(unlet):E108: No such variable: "novar"
7010
7011 次のコマンドを実行すると、 >
7012         :dwim
7013 通常次のエラーメッセージが表示される  >
7014         E492: Not an editor command: dwim
7015 これはtry条件文の中では例外に変換される >
7016         Vim:E492: Not an editor command: dwim
7017
7018 ":unlet"の全てのエラーを次によって捕捉できる >
7019         :catch /^Vim(unlet):/
7020 また、全てのミススペルされたコマンドのエラーは次で捕捉できる  >
7021         :catch /^Vim:E492:/
7022
7023 複数のコマンドによって同一のエラーメッセージが表示される場合もある: >
7024         :function nofunc
7025 と  >
7026         :delfunction nofunc
7027 は両方とも次のエラーメッセージを表示する。
7028         E128: Function name must start with a capital: nofunc
7029 これはtry条件節の中では例外に変換される。それぞれ >
7030         Vim(function):E128: Function name must start with a capital: nofunc
7031 または  >
7032         Vim(delfunction):E128: Function name must start with a capital: nofunc
7033 となる。どのコマンドによって発生したかに関係なくこのエラーを捕捉するには、次の
7034 正規表現を使う: >
7035         :catch /^Vim(\a\+):E128:/
7036
7037 複数のエラーメッセージを表示するコマンドもある:  >
7038         :let x = novar
7039 は次のエラーメッセージを表示する: >
7040         E121: Undefined variable: novar
7041         E15: Invalid expression:  novar
7042 最初のエラーメッセージのみが例外の値として使われる。それが最も限定的なメッセー
7043 ジだからである(|except-several-errors|を参照)。これは次のようにして捕捉できる
7044 >
7045         :catch /^Vim(\a\+):E121:/
7046
7047 "nofunc"という名前に関係したエラー全てを捕捉するには >
7048         :catch /\<nofunc\>/
7049
7050 コマンド":write"と":read"による全てのVimエラーを捕捉するには >
7051         :catch /^Vim(\(write\|read\)):E\d\+:/
7052
7053 全てのVimエラーを捕捉するには次の正規表現を使う >
7054         :catch /^Vim\((\a\+)\)\=:E\d\+:/
7055 <
7056                                                         *catch-text*
7057 NOTE: エラーメッセージの本文によって捕捉しようとしてはならない >
7058         :catch /No such variable/
7059 こうすると英語の環境では動作するが、コマンド |:language|により他の言語を使って
7060 いるユーザの環境では動作しなくなる。しかし、コメントとしてメッセージテキストを
7061 引用することは役に立つ: >
7062         :catch /^Vim(\a\+):E108:/   " No such variable
7063
7064 エラーを無視する                                        *ignore-errors*
7065
7066 特定のコマンドで発生したエラーを捕捉すれば、エラーを無視することができる: >
7067
7068         :try
7069         :  write
7070         :catch
7071         :endtry
7072
7073 しかしこの単純な形は使わないよう強く推奨されている。なぜなら、これはあなたが望
7074 むより多くの例外を捕捉してしまうからである。":write"コマンドを使うと自動コマン
7075 ドが実行され、書き込みとは関係ないエラーが発生する可能性がある。例えば: >
7076
7077         :au BufWritePre * unlet novar
7078
7079 このようなエラーの中には、スクリプトの作者が責任を追わないものもある: つまり、
7080 スクリプトのユーザがそのようなオートコマンドを定義している場合である。その
7081 場合、上の例のようにすると、ユーザからエラーを隠してしまうことになる。エラーを
7082 無視するには、次のようにした方がよい >
7083
7084         :try
7085         :  write
7086         :catch /^Vim(write):/
7087         :endtry
7088
7089 これは書き込みエラーだけを捕捉する。つまり、あなたが意図的に無視したいエラーだ
7090 けである。
7091
7092 オートコマンドを発生させないような1つのコマンドに対しては、":silent!"を使えば
7093 エラーを例外に変換すること自体を抑制させることができる: >
7094         :silent! nunmap k
7095 これはtry条件文が有効なときも機能する。
7096
7097
7098 割り込みを捕捉する                                       *catch-interrupt*
7099
7100 有効なtry条件文内では、割り込み(CTRL-C)は例外"Vim:Interrupt"に変換される。これ
7101 を他の例外と同様に捕捉することができる。するとそのスクリプトは停止しない。
7102    例: >
7103
7104         :function! TASK1()
7105         :  sleep 10
7106         :endfunction
7107
7108         :function! TASK2()
7109         :  sleep 20
7110         :endfunction
7111
7112         :while 1
7113         :  let command = input("Type a command: ")
7114         :  try
7115         :    if command == ""
7116         :      continue
7117         :    elseif command == "END"
7118         :      break
7119         :    elseif command == "TASK1"
7120         :      call TASK1()
7121         :    elseif command == "TASK2"
7122         :      call TASK2()
7123         :    else
7124         :      echo "\nIllegal command:" command
7125         :      continue
7126         :    endif
7127         :  catch /^Vim:Interrupt$/
7128         :    echo "\nCommand interrupted"
7129         :    " 例外捕捉。次のプロンプトから継続する。
7130         :  endtry
7131         :endwhile
7132
7133 ここでCTRL-Cを押すとタスクに割り込むことができる。その後スクリプトは新しいコマ
7134 ンドを要求する。プロンプトでCTRL-Cを押すとスクリプトが終了する。
7135
7136 スクリプト中の特定の行でCTRL-Cが押されたとき何が起こるかをテストするにはデバッ
7137 グモードを使い、その行の上で|>quit|や|>interrupt|コマンドを使う。
7138 |debug-scripts|を参照。
7139
7140
7141 全てを捕捉する                                         *catch-all*
7142
7143 次のコマンド >
7144
7145         :catch /.*/
7146         :catch //
7147         :catch
7148
7149 は全てをエラー例外・割り込み例外・|:throw|コマンドにより明示的に投げられた例外
7150 の捕捉する。これは、スクリプトのトップレベルで、予期しないことを捕捉するために
7151 役に立つ。
7152    例: >
7153
7154         :try
7155         :
7156         :  " ここで難しいことをする
7157         :
7158         :catch /MyException/
7159         :
7160         :  " 既知の問題を制御する
7161         :
7162         :catch /^Vim:Interrupt$/
7163         :    echo "Script interrupted"
7164         :catch /.*/
7165         :  echo "Internal error (" . v:exception . ")"
7166         :  echo " - occurred at " . v:throwpoint
7167         :endtry
7168         :" スクリプトの終わり
7169
7170 Note: 全てを捕捉すると、期待していた以上のものを捕捉してしまうかもしれない。そ
7171 れゆえ、":catch"コマンドの引数に正規表現を指定することにより、自分が本当に制御
7172 できる問題だけを捕捉することが強く推奨されている。
7173 全てを捕捉してしまうと、CTRL-Cを押してスクリプトを中断することがほぼ不可能になっ
7174 てしまうことがある。その例: >
7175
7176         :while 1
7177         :  try
7178         :    sleep 1
7179         :  catch
7180         :  endtry
7181         :endwhile
7182
7183
7184 例外とオートコマンド                              *except-autocmd*
7185
7186 オートコマンドの実行中に例外を使うこともできる。例: >
7187
7188         :autocmd User x try
7189         :autocmd User x   throw "Oops!"
7190         :autocmd User x catch
7191         :autocmd User x   echo v:exception
7192         :autocmd User x endtry
7193         :autocmd User x throw "Arrgh!"
7194         :autocmd User x echo "Should not be displayed"
7195         :
7196         :try
7197         :  doautocmd User x
7198         :catch
7199         :  echo v:exception
7200         :endtry
7201
7202 上の例を実行すると"Oops!"と"Arrgh!"が表示される。
7203
7204                                                         *except-autocmd-Pre*
7205 いくつかのコマンドでは、それ自身が実行される前にオートコマンドが実行される。
7206 例外が発生し、それが一連のオートコマンドの中で捕捉されない場合、一連の自動コマ
7207 ンドと、その引き金となったコマンドは破棄され、例外がそのコマンドを呼んだ位置へ
7208 伝播する。
7209    例: >
7210
7211         :autocmd BufWritePre * throw "FAIL"
7212         :autocmd BufWritePre * echo "Should not be displayed"
7213         :
7214         :try
7215         :  write
7216         :catch
7217         :  echo "Caught:" v:exception "from" v:throwpoint
7218         :endtry
7219
7220 ここで":write"コマンドは現在編集しているファイルを書き込まない('modified'を確
7221 認すればわかる)。BufWritePreのオートコマンドで発生した例外により、":write"が破
7222 棄されたためである。そしてその例外は捕捉され、次を表示する: >
7223
7224         Caught: FAIL from BufWrite Auto commands for "*"
7225 <
7226                                                         *except-autocmd-Post*
7227 いくつかのコマンドでは、それ自身が実行された後でオートコマンドが実行される。引
7228 き金となったコマンド自身が失敗して、それが有効なtry条件文の内側にあった場合、
7229 自動コマンドはスキップされ、エラー例外が発生する。その例外は、コマンドを呼んだ
7230 位置で捕捉することができる。
7231    例: >
7232
7233         :autocmd BufWritePost * echo "File successfully written!"
7234         :
7235         :try
7236         :  write /i/m/p/o/s/s/i/b/l/e
7237         :catch
7238         :  echo v:exception
7239         :endtry
7240
7241 この例は次を表示する: >
7242
7243         Vim(write):E212: Can't open file for writing (/i/m/p/o/s/s/i/b/l/e)
7244
7245 引き金となったコマンドが失敗したときでさえもオートコマンドを実行したいという場
7246 合は、catch節の中でそのイベントを引き起こすことできる。
7247    例: >
7248
7249         :autocmd BufWritePre  * set noreadonly
7250         :autocmd BufWritePost * set readonly
7251         :
7252         :try
7253         :  write /i/m/p/o/s/s/i/b/l/e
7254         :catch
7255         :  doautocmd BufWritePost /i/m/p/o/s/s/i/b/l/e
7256         :endtry
7257 <
7258 ":silent!"を使うこともできる: >
7259
7260         :let x = "ok"
7261         :let v:errmsg = ""
7262         :autocmd BufWritePost * if v:errmsg != ""
7263         :autocmd BufWritePost *   let x = "after fail"
7264         :autocmd BufWritePost * endif
7265         :try
7266         :  silent! write /i/m/p/o/s/s/i/b/l/e
7267         :catch
7268         :endtry
7269         :echo x
7270
7271 上の例は"after fail"を表示する。
7272
7273 引き金となったコマンドが失敗しなかった場合、オートコマンドから発生した例外は、
7274 元のコマンドを呼んだ位置から捕捉できる: >
7275
7276         :autocmd BufWritePost * throw ":-("
7277         :autocmd BufWritePost * echo "Should not be displayed"
7278         :
7279         :try
7280         :  write
7281         :catch
7282         :  echo v:exception
7283         :endtry
7284 <
7285                                                         *except-autocmd-Cmd*
7286 いくつかのコマンドでは、通常の処理を一連のオートコマンドで置き換えることができ
7287 る。そのコマンド列で発生した例外は元のコマンドの呼び出し位置で捕捉できる。
7288    例: ":write"コマンドでは、例外が発生したとき、呼び出し側は実際にファイルが
7289 書き込まれたのかどうかを知ることができない。これを教える必要があるときは、なん
7290 らかの手段を使わねばならない。 >
7291
7292         :if !exists("cnt")
7293         :  let cnt = 0
7294         :
7295         :  autocmd BufWriteCmd * if &modified
7296         :  autocmd BufWriteCmd *   let cnt = cnt + 1
7297         :  autocmd BufWriteCmd *   if cnt % 3 == 2
7298         :  autocmd BufWriteCmd *     throw "BufWriteCmdError"
7299         :  autocmd BufWriteCmd *   endif
7300         :  autocmd BufWriteCmd *   write | set nomodified
7301         :  autocmd BufWriteCmd *   if cnt % 3 == 0
7302         :  autocmd BufWriteCmd *     throw "BufWriteCmdError"
7303         :  autocmd BufWriteCmd *   endif
7304         :  autocmd BufWriteCmd *   echo "File successfully written!"
7305         :  autocmd BufWriteCmd * endif
7306         :endif
7307         :
7308         :try
7309         :       write
7310         :catch /^BufWriteCmdError$/
7311         :  if &modified
7312         :    echo "Error on writing (file contents not changed)"
7313         :  else
7314         :    echo "Error after writing"
7315         :  endif
7316         :catch /^Vim(write):/
7317         :    echo "Error on writing"
7318         :endtry
7319
7320 バッファに変更を行った後でこのスクリプトを数回sourceすると、1回目は次のように
7321 表示される >
7322         File successfully written!
7323 2回目は >
7324         Error on writing (file contents not changed)
7325 3回目は >
7326         Error after writing
7327 以下同様。
7328
7329                                                         *except-autocmd-ill*
7330 異なるイベントに対するオートコマンドにわたってtry条件文を展開することはできな
7331 い。以下のコードは不正である: >
7332
7333         :autocmd BufWritePre  * try
7334         :
7335         :autocmd BufWritePost * catch
7336         :autocmd BufWritePost *   echo v:exception
7337         :autocmd BufWritePost * endtry
7338         :
7339         :write
7340
7341
7342 例外の階層と付加情報つき例外                          *except-hier-param*
7343
7344 プログラミング言語の中には例外クラスを階層化したり、例外クラスのオブジェクトに
7345 付加的な情報を渡すことができるものがある。これと似たことをVimでもできる。
7346 階層構造を持った例外を投げるには、各部分をコロンで区切った完全なクラス名を投げ
7347 ればよい。例えば、数学ライブラリ内でオーバーフローが発生したときに
7348 "EXCEPT:MATHERR:OVERFLOW"を投げる。
7349 例外クラスに付加的な情報を与えたいときは、それを括弧の中に書く。例えば、
7350 "myfile"の書き込み中にエラーが発生したときに文字列"EXCEPT:IO:WRITEERR(myfile)"
7351 を投げる。
7352 ":catch"コマンドにおいて適切な正規表現を使えば、階層の基底クラスや派生クラスを
7353 捕捉できる。括弧の中の付加情報は、":substitute"コマンドを使って|v:exception|か
7354 ら切り出すことができる。
7355 例: >
7356
7357         :function! CheckRange(a, func)
7358         :  if a:a < 0
7359         :    throw "EXCEPT:MATHERR:RANGE(" . a:func . ")"
7360         :  endif
7361         :endfunction
7362         :
7363         :function! Add(a, b)
7364         :  call CheckRange(a:a, "Add")
7365         :  call CheckRange(a:b, "Add")
7366         :  let c = a:a + a:b
7367         :  if c < 0
7368         :    throw "EXCEPT:MATHERR:OVERFLOW"
7369         :  endif
7370         :  return c
7371         :endfunction
7372         :
7373         :function! Div(a, b)
7374         :  call CheckRange(a:a, "Div")
7375         :  call CheckRange(a:b, "Div")
7376         :  if (a:b == 0)
7377         :    throw "EXCEPT:MATHERR:ZERODIV"
7378         :  endif
7379         :  return a:a / a:b
7380         :endfunction
7381         :
7382         :function! Write(file)
7383         :  try
7384         :    execute "write" fnameescape(a:file)
7385         :  catch /^Vim(write):/
7386         :    throw "EXCEPT:IO(" . getcwd() . ", " . a:file . "):WRITEERR"
7387         :  endtry
7388         :endfunction
7389         :
7390         :try
7391         :
7392         :  " 計算やI/Oを行う
7393         :
7394         :catch /^EXCEPT:MATHERR:RANGE/
7395         :  let function = substitute(v:exception, '.*(\(\a\+\)).*', '\1', "")
7396         :  echo "Range error in" function
7397         :
7398         :catch /^EXCEPT:MATHERR/        " catches OVERFLOW and ZERODIV
7399         :  echo "Math error"
7400         :
7401         :catch /^EXCEPT:IO/
7402         :  let dir = substitute(v:exception, '.*(\(.\+\),\s*.\+).*', '\1', "")
7403         :  let file = substitute(v:exception, '.*(.\+,\s*\(.\+\)).*', '\1', "")
7404         :  if file !~ '^/'
7405         :    let file = dir . "/" . file
7406         :  endif
7407         :  echo 'I/O error for "' . file . '"'
7408         :
7409         :catch /^EXCEPT/
7410         :  echo "Unspecified error"
7411         :
7412         :endtry
7413
7414 エラー時やCTRL-Cを押したときにVim自身によって投げられる例外は平坦な階層になっ
7415 ている: つまりこれらは全て"Vim"クラスに入っている。ユーザは接頭辞"Vim"をつけた
7416 例外を投げることはできない。これらはVim用に予約されている。
7417 Vimのエラー例外は失敗したコマンドの名前(わかっているならば)という付加情報がつ
7418 いている。|catch-errors|を参照。
7419
7420
7421 変わった特性
7422                                                         *except-compat*
7423 例外制御のコンセプトは、例外を引き起こしたコマンドは即座に異常終了し、制御が
7424 finally節またはcatch節に移るという前提に基づいている。
7425
7426 Vimスクリプト言語では、エラーの後もスクリプトや関数が処理を続行する場合がある。
7427 "abort"フラグのない関数や、":silent!"をつけて実行されたコマンドでは、制御は次
7428 の行、そして関数の外へ移り、制御フローは最外側の":endwhile"や":endif"の次の行へ
7429 移る。一方、エラーは例外と同様に捕捉できるべきである(つまり、即座に異常終了す
7430 ることが要求される)。
7431
7432 この問題は、try条件文が有効なときだけエラーを例外に変換し、(":silent!"で抑制さ
7433 れていない限り)即座に異常終了することで解決される。(エラー)例外は有効なtry条件
7434 文でのみ捕捉可能であるため、これはなんら制約とはならない。エラーを捕捉せずに即
7435 座に終了してほしいなら、単にcatch節を持たないtry条件文を使えばよい。(finally節
7436 を指定すれば、終了の前に後始末処理を行うことができる)
7437
7438 有効なtry条件文がないとき、即座の異常終了でなく、通常の異常終了と継続が行われ
7439 る。これによってVim6.1以前用に書かれたスクリプトの互換性を保証している。
7440
7441 しかし、有効なtry条件文の中から、例外処理コマンドを使っていない既存のスクリプ
7442 トをsourceする(またはその関数の1つを呼ぶ)と、エラー発生時に既存のスクリプトの
7443 制御フローが変わるかもしれない。エラー発生時に即座に異常終了し、新しい方のスク
7444 リプト内でエラーを捕捉できる。しかしsourceされたスクリプトが":silent!"コマンド
7445 でエラーメッセージを抑制していた場合(それが適切なスクリプトなら|v:errmsg|を見
7446 ることでエラーを確認している)、実行パスは変わらない。そのエラーは例外に変換さ
7447 れない(|:silent|を参照)。これが起こる残りのただ1つの原因は、エラーに関心を払っ
7448 ていなく、エラーメッセージを表示させるスクリプトである。おそらく新しいスクリプ
7449 トからそのようなコードを使いたいとは思わないだろう。
7450
7451                                                         *except-syntax-err*
7452 例外処理コマンドにおける構文エラーは、それが属するtry条件文のどの":catch"コマ
7453 ンドでも決して捕捉されない。しかしfinally節は実行される。
7454    例: >
7455
7456         :try
7457         :  try
7458         :    throw 4711
7459         :  catch /\(/
7460         :    echo "in catch with syntax error"
7461         :  catch
7462         :    echo "inner catch-all"
7463         :  finally
7464         :    echo "inner finally"
7465         :  endtry
7466         :catch
7467         :  echo 'outer catch-all caught "' . v:exception . '"'
7468         :  finally
7469         :    echo "outer finally"
7470         :endtry
7471
7472 上の例を実行すると次が表示される: >
7473     inner finally
7474     outer catch-all caught "Vim(catch):E54: Unmatched \("
7475     outer finally
7476 元の例外は破棄され、代わりにエラー例外が投げられる。
7477
7478 訳注: throw 4711により例外が発生したが、その後の catch /\(/ に構文エラーがある
7479 訳注: ためエラー例外が発生し、最初の例外は破棄された。
7480
7481                                                         *except-single-line*
7482 コマンド":try", ":catch", ":finally", ":endtry"は1行の中に書くことができる。し
7483 かし構文エラーがあったとき"catch"の行を認識するのが難しくなるので、避けた方が
7484 よい。
7485    例: >
7486         :try | unlet! foo # | catch | endtry
7487 この例は":unlet!"の後に余計な文字があるためエラー例外を発生させる。そして
7488 ":catch"と":endtry"が認識されないため、この例外は破棄され、"E488: Trailing
7489 characters"のメッセージが表示される。
7490
7491                                                         *except-several-errors*
7492 1つのコマンドにより複数のエラーが発生した場合、普通は最初のエラーメッセージが
7493 最も限定的であるため、それがエラー例外に変換される。
7494    例: >
7495         echo novar
7496 は次を発生させる: >
7497         E121: Undefined variable: novar
7498         E15: Invalid expression: novar
7499 try条件文の中のエラー例外の値は次になる: >
7500         Vim(echo):E121: Undefined variable: novar
7501 <                                                       *except-syntax-error*
7502 しかし、同じコマンドにおいて通常のエラーの後に構文エラーが検出されたときは、構
7503 文エラーが例外として投げられる。
7504    例: >
7505         unlet novar #
7506 これは次を発生させる: >
7507         E108: No such variable: "novar"
7508         E488: Trailing characters
7509 try条件文の中のエラー例外の値は次になる: >
7510         Vim(unlet):E488: Trailing characters
7511 この理由は、構文エラーによってユーザが予期していない実行パスになってしまうかも
7512 しれないためである。例: >
7513         try
7514             try | unlet novar # | catch | echo v:exception | endtry
7515         catch /.*/
7516             echo "outer catch:" v:exception
7517         endtry
7518 これは"outer catch: Vim(unlet):E488: Trailing characters"を表示し、次にエラー
7519 メッセージ "E600: Missing :endtry"が表示される。|except-single-line|を参照。
7520
7521 ==============================================================================
7522 9. 例                                                        *eval-examples*
7523
7524 16進数で表示する ~
7525 >
7526   :" 関数 Nr2Bin() は数値の2進文字列表現を返す。
7527   :func Nr2Bin(nr)
7528   :  let n = a:nr
7529   :  let r = ""
7530   :  while n
7531   :    let r = '01'[n % 2] . r
7532   :    let n = n / 2
7533   :  endwhile
7534   :  return r
7535   :endfunc
7536
7537   :" 関数 String2Bin() は文字列中の各文字を2進文字列に変換して、ハイフン(-)で
7538   :" 区切って返す。
7539   :func String2Bin(str)
7540   :  let out = ''
7541   :  for ix in range(strlen(a:str))
7542   :    let out = out . '-' . Nr2Bin(char2nr(a:str[ix]))
7543   :  endfor
7544   :  return out[1:]
7545   :endfunc
7546
7547 使い方の例: >
7548   :echo Nr2Bin(32)
7549 結果: "100000" >
7550   :echo String2Bin("32")
7551 結果: "110011-110010"
7552
7553
7554
7555 行をソート(並べ替え)する (by Robert Webb) ~
7556
7557 以下は、指定した比較関数を使って行をソートする例である。 >
7558
7559   :func SortBuffer()
7560   :  let lines = getline(1, '$')
7561   :  call sort(lines, function("Strcmp"))
7562   :  call setline(1, lines)
7563   :endfunction
7564
7565 ワンライナーにすると次のようになる: >
7566   :call setline(1, sort(getline(1, '$'), function("Strcmp")))
7567
7568 scanf() の代替 ~
7569                                                         *sscanf*
7570 Vimにはsscanf()に相当する関数が無い。行の一部を取り出す必要がある場合には、
7571 matchstr()やsubstitute()を使えば実現できる。以下の例は、"foobar.txt, 123, 45"
7572 というような行から、ファイル名と行番号とカラム番号を取り出す方法を示している。
7573 >
7574    :" 正規表現を設定
7575    :let mx='\(\f\+\),\s*\(\d\+\),\s*\(\d\+\)'
7576    :" 正規表現全体にマッチする部分を取り出す
7577    :let l = matchstr(line, mx)
7578    :" マッチ結果から各要素を取り出す
7579    :let file = substitute(l, mx, '\1', '')
7580    :let lnum = substitute(l, mx, '\2', '')
7581    :let col = substitute(l, mx, '\3', '')
7582
7583 入力は変数"line"、結果は"file"と"lnum"と"col"に格納される(このアイデアは
7584 Michael Geddesによる)。
7585
7586
7587 辞書からscriptnamesを取り出す ~
7588                                                 *scriptnames-dictionary*
7589 コマンド|:scriptnames|により今までにsourceされた全てのスクリプトファイルのリス
7590 トを取得することができる。これと等価な関数や変数は存在しない(めったに必要にな
7591 らないからである)。そのような場合には次のコードが利用できる: >
7592     " ":scriptnames" の出力を変数scriptnames_outputに入れる。
7593     let scriptnames_output = ''
7594     redir => scriptnames_output
7595     silent scriptnames
7596     redir END
7597
7598     " 出力を行のリストに分割し、各行をパースする。辞書"scripts"に要素を追加
7599     " する。
7600     let scripts = {}
7601     for line in split(scriptnames_output, "\n")
7602       " 空行以外に対して実行
7603       if line =~ '\S'
7604         " 行内の最初の番号を取得
7605         let nr = matchstr(line, '\d\+')
7606         " ファイル名を取得。スクリプト番号" 123: "を削除。
7607         let name = substitute(line, '.\+:\s*', '', '')
7608         " 辞書に要素を追加
7609         let scripts[nr] = name
7610       endif
7611     endfor
7612     unlet scriptnames_output
7613
7614 ==============================================================================
7615 10. +eval機能が無効                                  *no-eval-feature*
7616
7617 コンパイル時に|+eval|機能が無効とされている場合、総ての式評価(eval)コマンドは
7618 提供されない。その場合、Vimスクリプトが総ての種類のエラーを引き起こすことを避
7619 ける為、":if"と":endif"は解釈される。":if"とそれに対応する":endif"に挟まれた内
7620 容は無視される。":if"の後に続く引数も無視される。この":if"コマンドはネスティン
7621 グが可能である。しかし必ず行の先頭に書かれている必要がある。":else"コマンドは
7622 認識されない。
7623
7624 |+eval|機能が存在しなかった場合、どのようにコマンドが実行を免れるかの例: >
7625
7626         :if 1
7627         :  echo "Expression evaluation is compiled in"
7628         :else
7629         :  echo "You will _never_ see this message"
7630         :endif
7631
7632 ==============================================================================
7633 11. サンドボックス                             *eval-sandbox* *sandbox* *E48*
7634
7635 オプション 'foldexpr', 'includeexpr', 'indentexpr', 'statusline', 'foldtext'
7636 はサンドボックスの中で評価される。これによって、悪質な副作用を持つ式からの保護
7637 がなされている。これによって、これらのオプションがモードラインから設定された場合
7638 にある種の安全性がもたらされている。tagsファイルからのコマンドが実行されたとき
7639 とコマンドラインでのCTRL-R =に対してもサンドボックスが使われる。
7640 コマンド|:sandbox|に対してもサンドボックスが使われる。
7641
7642 サンドボックス内では以下の事が禁止される:
7643         - バッファの変更
7644         - マッピング、オートコマンド、関数、ユーザ定義コマンドの定義・変更
7645         - ある種のオプションの設定 (|option-summary|を参照)
7646         - ある種のVim定義済変数(v:)の設定 (|v:var|を参照)  *E794*
7647         - シェルコマンドの実行
7648         - ファイルの読み書き
7649         - 他のバッファへの移動・ファイルを開く
7650         - Python, Perl等のコマンドの実行
7651 これは100%安全と保証するものではない。しかし、ある種の攻撃を防ぐ事はできるはずで
7652 ある。
7653
7654                                                         *:san* *:sandbox*
7655 :san[dbox] {cmd}        サンドボックス内で{cmd}を実行する。モードラインから設
7656                         定された可能性のあるオプションを評価するために使える。
7657                         例: 'foldexpr'.
7658
7659                                                         *sandbox-option*
7660 いくつかのオプションは式を含んでいる。その式を評価するときはセキュリティ上の危
7661 険性を回避するためにサンドボックス内で行わねばならない。しかしサンドボックスに
7662 は制限があるので、これはそのオプションが安全でない場所で設定されたときのみ行わ
7663 れる。ここで「安全でない」とは次の場合をいう:
7664 - カレントディレクトリの .vimrc や .exrc を source するとき
7665 - サンドボックス内で実行している最中
7666 - モードラインから設定された値
7667
7668 Note サンドボックス内でオプションの値を退避し、それから復元した場合、そのオプ
7669 ションはやはりサンドボックス内で設定されたものとマークされる。
7670
7671 ==============================================================================
7672 12. テキストロック                                             *textlock*
7673
7674 いくつか状況においては、バッファを変更する・他のウィンドウへジャンプするなど、
7675 Vimの現在の処理を混乱させたり破壊してしまうような動作は禁止される。これはVimが
7676 実際に他の何かをしているときに起こることに対して当てはまる。例えば、
7677 'balloonexpr'の評価は、マウスカーソルがある位置に留まっているどんなときにでも
7678 起こりうる。
7679
7680 テキストロックが有効になっているときは、以下の事が禁止される:
7681         - バッファの変更
7682         - 他のバッファやウィンドウへの移動
7683         - 他のファイルを開く
7684         - ウィンドウを閉じる。Vimを終了する。
7685         - など。
7686
7687
7688  vim:tw=78:ts=8:ft=help:norl: