vim-jp / vimdoc-ja / eval

eval - Vim日本語ドキュメント

メインヘルプファイルに戻る English | 日本語
eval.txt      For Vim バージョン 8.0.  Last change: 2017 Mar 09


                VIMリファレンスマニュアル    by Bram Moolenaar


Vim script                              expression expr E15 eval

Vim script の利用についてはユーザーマニュアルの41章usr_41.txtでも解説され
ている。

注意: Vim script はコンパイル時に無効化できる。もしそうなっているとこのド
キュメントに書かれている事は有効ではない。+evalno-eval-featureを参照。

1.  変数                variables
    1.1 変数の型
    1.2 関数への参照            Funcref
    1.3 リスト                  Lists
    1.4 辞書                    Dictionaries
    1.5 変数について補足        more-variables
2.  式の文法            expression-syntax
3.  内部変数            internal-variables
4.  組み込み関数        functions
5.  関数定義            user-functions
6.  波括弧{}変数        curly-braces-names
7.  コマンド            expression-commands
8.  例外処理            exception-handling
9.  例                  eval-examples
10. +eval機能が無効     no-eval-feature
11. サンドボックス      eval-sandbox
12. テキストロック      textlock
13. テスト              testing

{Vi にはこれらのコマンドはない}

==============================================================================
1. 変数                                                 variables

1.1 変数の型
                                                        E712
変数には9種類の型がある:

数値            32ビットまたは64ビットの符号有整数。expr-number Number
                64ビット数値は +num64 機能つきでコンパイルされたときのみ有効。
                例:  -123  0x10  0177  0b1011

浮動小数点数    浮動小数点数。floating-point-format Float
                {+float 機能つきでコンパイルされたときのみ}
                例: 123.456  1.15e-6  -1.1e3

文字列          終端がNUL文字である8ビットの符号無し文字(バイト)。
                expr-string 例: "ab\txx\"--"  'x-z''a,c'

リスト          要素の順序つきの列 List
                例: [1, 2, ['a', 'b']]

辞書            順序を持たない連想配列: 各要素はキーと値を持つ。Dictionary
                例: {'blue': "#0000ff", 'red': "#ff0000"}

Funcref         関数への参照 Funcref
                例: function("strlen")
                辞書や引数とバインドすることができ、そのときは部分適用(Partial)
                のように働く。
                例: function("Callback", [arg], myDict)

特殊値          v:falsev:truev:none と v:null。  Special

ジョブ          ジョブに使われる。job_start()を参照。 Job Jobs

チャンネル      チャンネルに使われる。ch_open()を参照。 Channel Channels

数値と文字列は文脈に応じて相互に変換される。

数値から文字列への変換は数字のASCII表現によって行われる。例:
        数値 123        -->     文字列 "123"
        数値 0          -->     文字列 "0"
        数値 -1         -->     文字列 "-1"
                                                        octal
文字列から数値への変換は最初の数字を用いて数値に変換する。16進表記 "0xf9" や
8進表記 "017"、2進数表記の "0b10" も認識される。文字列が数字で始まらない場合結
果は0となる。例:
        文字列 "456"    -->     数値 456
        文字列 "6bar"   -->     数値 6
        文字列 "foo"    -->     数値 0
        文字列 "0xf1"   -->     数値 241
        文字列 "0100"   -->     数値 64
        文字列 "0b101"  -->     数値 5
        文字列 "-8"     -->     数値 -8
        文字列 "+8"     -->     数値 0

文字列を強制的に数値に変換するには0を足す:
        :echo "0100" + 0
        64

先頭の0によって8進数とみなされるのを防いだり、異なる基数を使うにはstr2nr()
使う。

                                                        TRUE FALSE
ブール(真理値)演算には数値が使われる。0は偽を意味し、非0は真を表す。また、
v:false と v:true を使うこともできる。関数から真が返されたときは数値の 1
であり、偽が返されたときは数値の 0 である。

Note 次のコマンドをみると
        :if "foo"
        :" 実行されない
"foo" は 0 に変換され、それは偽を意味する。もし文字列がゼロでない数値から始ま
る場合は真を意味する:
        :if "8foo"
        :" 実行される
文字列が空ではないか調べるためには empty() を使用して次のようにする。
        :if !empty("foo")

                                                        non-zero-arg
関数の引数は、TRUE とは少し異なる場合がある: 引数が存在し、それが非ゼロの
Number、v:true または空でない String に評価される場合、値は TRUE と見なされ
る。" " と "0" も空文字列ではないので、モードをクリアするのに注意すること。
List、Dictionary、または Float は数値または文字列ではないため、FALSE と評価さ
れる。

                E745 E728 E703 E729 E730 E731 E908 E910 E913
リスト、辞書、Funcref、ジョブ、チャンネルは自動的に変換されない。

                                                        E805 E806 E808
数値と浮動小数点数をまぜると浮動小数点数になる。それ以外には浮動小数点数への自
動的な変換は存在しない。文字列から浮動小数点数へは str2float() を使い、浮動小
数点数から文字列へは printf() を、浮動小数点数から数値へは float2nr() を使う。

                        E891 E892 E893 E894 E907 E911 E914
浮動小数点数が予期されているところでは数値も使用可能だが、それ以外は使用できな
い。

                                                no-type-checking
変数の型を変更しようとしてもエラーは発生しない。


1.2 関数への参照
                                        Funcref E695 E718
関数への参照は、関数function()、関数funcref()またはラムダ式expr-lambda
使うことで得られる。関数への参照は、式の中で関数名が要求される場所で使うと参照
先の関数を呼び出す。例:

        :let Fn = function("MyFunc")
        :echo Fn()
                                                        E704 E705 E707
関数参照の変数名は、大文字、"s:"、"w:"、"t:"、"b:" のいずれかで始めなければな
らない。"g:" も使えるが、あとに続く名前は大文字で始めなければならない。関数参
照と参照先の関数の名前を同じにすることはできない。

関数を定義して、それへの参照を直接辞書に入れるための特別な形式がある。例:
        :function dict.init() dict
        :   let self.val = 0
        :endfunction

この辞書のキーは小文字で始めなければならない。実際の関数名はここでは使われない。
numbered-functionも参照。

:callコマンドでも関数参照を使うことができる:
        :call Fn()
        :call dict.init()

参照先の関数名はstring()で得られる。
        :let func = string(Fn)

call()を使うと、リスト型の変数を引数として関数参照を呼び出すことができる:
        :let r = call(Fn, mylist)

                                                                Partial
関数参照は、辞書および/もしくは引数とバインドすることができる。これは部分適用
(Partial)とも呼ばれる。これは、辞書および/もしくは引数を function() または
funcref() に渡すことで作成される。その関数を呼び出すと、その辞書および/もしく
は引数がその関数に渡される。例:

        let Cb = function('Callback', ['foo'], myDict)
        call Cb()

これは、関数を以下のようにして呼び出す:
        call myDict.Callback('foo')

これは関数を何かに渡す場合、例えば ch_open() の引数とする場合などに非常に有
用である。

Note 関数の辞書へのバインドは、その関数が辞書のメンバーであるときにも発生する
ことに注意:

        let myDict.myFunction = MyFunction
        call myDict.myFunction()

ここで、MyFunction() は myDict を "self" として受け取る。これは、"myFunction"
メンバーがアクセスされたときに起こる。"myFunction" を別の辞書 otherDict に代入
して呼び出すと、それは otherDict にバインドされる:

        let otherDict.myFunction = myDict.myFunction
        call otherDict.myFunction()

今度は、"self" は "otherDict" になる。しかし、辞書を明示的にバインドしたときに
はこれは起こらない:

        let myDict.myFunction = function(MyFunction, myDict)
        let otherDict.myFunction = myDict.myFunction
        call otherDict.myFunction()

ここでは、"self" は "myDict" である。なぜなら明示的にバインドされているからで
ある。


1.3 リスト
                                                list List Lists E686
リストとは順序を保つ要素の列である。要素はどんな型でもよい。要素へはインデック
ス番号を使ってアクセスする。列の任意の位置に要素を追加したり削除することができ
る。


リストの作成
                                                        E696 E697
リストを作るには、[]の中にコンマで区切って要素を書く。
例:
        :let mylist = [1, two, 3, "four"]
        :let emptylist = []

要素はどんな式でもよい。要素としてリストを指定すると、リストのリストができる:

        :let nestlist = [[11, 12], [21, 22], [31, 32]]

最後の要素の後に余分なコンマがあると無視される。


リストのインデックス
                                                        list-index E684
リストの要素にアクセスするには、リスト名の後に[]を書き、その中にインデックスを
書く。インデックスは0基点(つまり最初の要素のインデックスは0)である。
        :let item = mylist[0]           " 最初の要素(1)を取得
        :let item = mylist[2]           " 3番目の要素(3)を取得

取得した要素がリストならば、さらに続けてインデックスを書くことができる:
        :let item = nestlist[0][1]      " 最初のリストの2番目の要素(12)を取得

負のインデックスを指定すると、リストの末尾から数えられる。インデックス-1は最後
の要素を示し、-2は最後から2番目を指す
        :let last = mylist[-1]          " 最後の要素("four")を取得

無効なインデックスによるエラーを回避するには関数get()を使う。するとインデッ
クスが無効な場合は、0かまたは自分で指定した既定値が返る:
        :echo get(mylist, idx)
        :echo get(mylist, idx, "NONE")


リストの連結

2つのリストを連結するには演算子 "+" を使う:
        :let longlist = mylist + [5, 6]
        :let mylist += [7, 8]

1個の要素を先頭または末尾に付け加えるには、[]で囲んでリストにして連結する。リ
ストの特定の要素を変更するには後述のlist-modificationを参照。


部分リスト
                                                        sublist
リストの一部分を取り出すには、[]の中に始点と終点のインデックスを書き、コロンで
区切る:
        :let shortlist = mylist[2:-1]   " リスト[3, "four"]を得る

始点のインデックスを省略すると0となる。終点のインデックスを省略すると-1となる
        :let endlist = mylist[2:]       " 2番目から最後まで: [3, "four"]
        :let shortlist = mylist[2:2]    " 1個の要素からなるリスト: [3]
        :let otherlist = mylist[:]      " リストのコピーを作る

終点のインデックスが始点のインデックスよりも前になってしまった場合は空リストと
なる。エラーメッセージは表示されない。

終点のインデックスがリストの長さより大きい場合は、長さ-1を指定したときと同じに
なる:
        :let mylist = [0, 1, 2, 3]
        :echo mylist[2:8]               " 結果: [2, 3]

NOTE: mylist[s:e]と書くと変数 "s:e" をインデックスとして使ったと解釈される。
":" の前に1文字の変数を使うときは十分注意すること。必要ならこのようにスペース
を入れるとよい: mylist[s : e].


リストの同一性
                                                        list-identity
変数 "aa" がリストであり、それを別の変数 "bb" に代入したとすると、両方とも同じ
変数を参照するようになる。よってリスト "aa" を変更すると "bb" も変更される:
        :let aa = [1, 2, 3]
        :let bb = aa
        :call add(aa, 4)
        :echo bb
        [1, 2, 3, 4]

リストのコピーを作るには関数copy()を使う。前述の通り[:]を使ってもできる。こ
れは浅いコピーである。つまりリストの要素であるリストに変更を加えると、コピーさ
れたリスト内の同じ要素も変更される:
        :let aa = [[1, 'a'], 2, 3]
        :let bb = copy(aa)
        :call add(aa, 4)
        :let aa[0][1] = 'aaa'
        :echo aa
        [[1, aaa], 2, 3, 4]
        :echo bb
        [[1, aaa], 2, 3]

完全に独立したコピーを作るにはdeepcopy()を使う。これは再帰的にリストの要素の
コピーを作る。ただし深さは100レベルまでである。

2つの変数が同じリストを指しているかは演算子 "is" で判定できる。"isnot" はその
逆である。一方、"==" は2つのリストが同じ値を持っているかを判定する。
        :let alist = [1, 2, 3]
        :let blist = [1, 2, 3]
        :echo alist is blist
        0
        :echo alist == blist
        1

Note リストの比較について注意: 2つのリストは、同じ長さを持ち、全要素が "==" の
意味で等しいとき、等しいとみなされる。ただ、1つ例外がある: 数値と文字列を比較
するとそれらは異なるとみなされる。変数に対して "==" で比較したときに行われるよ
うな自動的な型変換は行われない。例:
        echo 4 == "4"
        1
        echo [4] == ["4"]
        0

つまり、リストの比較は数値や文字列の比較よりも厳格である。単純な値もリストに入
れることによりこの方法で比較することができる:

        :let a = 5
        :let b = "5"
        :echo a == b
        1
        :echo [a] == [b]
        0


リストのアンパック

リストの要素を個々の変数としてアンパックするには、[]の中に変数を書く:
        :let [var1, var2] = mylist

変数の個数とリストの要素数が一致しないときはエラーになる。リストにある余分な要
素をまとめて受け取るには、";" と受け取る変数名を書いておく:
        :let [var1, var2; rest] = mylist

上の例は次とほぼ同じである:
        :let var1 = mylist[0]
        :let var2 = mylist[1]
        :let rest = mylist[2:]

要素が 2 つしかないときでもエラーにはならない。"rest" は空リストになる。


リストの変更
                                                        list-modification
リストの中の特定の要素を変更するには次のように:letを使う:
        :let list[4] = "four"
        :let listlist[0][3] = item

始点と終点を指定してリストの一部分を変更することができる。代入する値は、少なく
とも削除する範囲の要素数と同じ数だけ必要である:
        :let list[3:5] = [3, 4, 5]

リストに要素を追加したり削除するには関数を使う。いくつか例を示す:
        :call insert(list, 'a')         " 先頭に要素 'a' を挿入する
        :call insert(list, 'a', 3)      " 要素 'a' をlist[3]の前に挿入する
        :call add(list, "new")          " 文字列の要素を最後に追加する
        :call add(list, [1, 2])         " 1個の要素としてリストを追加する
        :call extend(list, [1, 2])      " 2個の要素からなるリストを連結する
        :let i = remove(list, 3)        " 要素3を削除する
        :unlet list[3]                  " 同上
        :let l = remove(list, 3, -1)    " 要素3から最後までを削除する
        :unlet list[3 : ]               " 同上
        :call filter(list, 'v:val !~ "x"')  " 要素 'x' を削除

要素の順番を変更する:
        :call sort(list)                " リストをアルファベット順にソート
        :call reverse(list)             " 要素の順序を反転させる
        :call uniq(sort(list))          " ソートして重複を削除する


for ループ

:forループは、1つの変数に対してリストの各要素を順番に代入し、コマンドを実行
していく。例:
        :for item in mylist
        :   call Doit(item)
        :endfor

上の例は次と同じ:
        :let index = 0
        :while index < len(mylist)
        :   let item = mylist[index]
        :   :call Doit(item)
        :   let index = index + 1
        :endwhile

やりたいことがリストの各要素を変更するだけなら、forループを使うより関数map()
を使った方がよりシンプルになる。

:letコマンドと同じように、:forは変数のリストをループ変数にすることができる。
この場合、引数はリストのリストでなければならない。
        :for [lnum, col] in [[1, 3], [2, 8], [3, 0]]
        :   call Doit(lnum, col)
        :endfor

これはリストの各要素に対して:letコマンドを実行するかのように実行される。また
この場合も引数の型は全て同じでないとエラーになる。

引数の残りを1個のリスト変数に代入することもできる:
        :for [i, j; rest] in listlist
        :   call Doit(i, j)
        :   if !empty(rest)
        :      echo "remainder: " . string(rest)
        :   endif
        :endfor


リスト操作関数
                                                E714
以下はリスト操作に使える関数である:
        :let r = call(funcname, list)   " 引数リストをつけて関数を呼び出す
        :if empty(list)                 " リストが空かどうか判定する
        :let l = len(list)              " リストの要素数
        :let big = max(list)            " リスト中の最大値
        :let small = min(list)          " リスト中の最小値
        :let xs = count(list, 'x')      " 'x' の出現回数を数える
        :let i = index(list, 'x')       " 最初に 'x' が現れる位置のインデックス
        :let lines = getline(1, 10)     " バッファから10行を取得
        :call append('$', lines)        " バッファに行を追加する
        :let list = split("a b c")      " 文字列を分割してリストにする
        :let string = join(list, ', ')  " リストの要素を連結して文字列にする
        :let s = string(list)           " リストの文字列表現
        :call map(list, '">> " . v:val')  " 各要素の前に ">> " をつける

機能を組み合わせると、処理を単純に記述できることを覚えておくとよい。例えば、リ
スト中の全ての数値の和を求める例:
        :exe 'let sum = ' . join(nrlist, '+')


1.4 辞書
                                        dict Dictionaries Dictionary
辞書とは連想配列である。各要素はキーと値を持つ。要素はキーによって特定できる。
要素は特に順序を持たずに保持される。


辞書の作成
                                                E720 E721 E722 E723
辞書を作るには、{}の中にコンマで区切って要素を書く。各要素のキーと値はコロンで
区切る。それぞれのキーは1度しか現れてはならない。例:
        :let mydict = {1: 'one', 2: 'two', 3: 'three'}
        :let emptydict = {}
                                                        E713 E716 E717
キーは必ず文字列である。数値を使うこともできるが、自動的に文字列に変換される。
よって文字列 '4' のキーと数値4のキーは同一の要素を参照する。
Note 文字列 '04' と数値04は異なることに注意。なぜなら数値04は文字列 '4' に変換
されるからである。空文字列もキーとして使用できる。

値はどんな式でもよい。辞書を値にすると、ネストした辞書ができる:
        :let nestdict = {1: {11: 'a', 12: 'b'}, 2: {21: 'c'}}

最後の要素の後に余分なコンマがあると無視される。


要素にアクセスする

通常、要素にアクセスするには[]の中にキーを書く:
        :let val = mydict["one"]
        :let mydict["four"] = 4

また、この書き方で既存の辞書に要素を追加できる。この点はリストと異なる。

キー名がアルファベット、数字、アンダースコアだけからなる場合は、以下の形式が使
えるexpr-entry:
        :let val = mydict.one
        :let mydict.four = 4

要素はリストや辞書を含むどんな型でもよいため、インデックス参照とキー参照を続け
て書くことができる:
        :echo dict.key[idx].key


辞書からリストへの変換

辞書の全要素に対してループを行いたい場合がある。そのためには辞書をリストに変換
し、そのリストに対して:forループを行う。

多くの場合はキーに対してループを行う。これには関数keys()を使う:
        :for key in keys(mydict)
        :   echo key . ': ' . mydict[key]
        :endfor

このキーのリストはソートされていない。ソートさせるには関数sort()を使う:
        :for key in sort(keys(mydict))

値に対してループを行うには関数values()を使う:
        :for v in values(mydict)
        :   echo "value: " . v
        :endfor

キーと値両方を得るには関数items()を使う。この関数は、キーと値の2個の要素から
なるリストのリストを返す:
        :for [key, value] in items(mydict)
        :   echo key . ': ' . value
        :endfor


辞書の同一性
                                                        dict-identity
辞書のコピーを作るにはリストと同様にcopy()deepcopy()を使う必要がある。そ
うでなく代入を行うと同一の辞書を参照するようになる:
        :let onedict = {'a': 1, 'b': 2}
        :let adict = onedict
        :let adict['a'] = 11
        :echo onedict['a']
        11

2つの辞書は、全てのキー・値のペアが等しいとき等しいとみなされる。より詳しくは
list-identityを参照。


辞書の変更
                                                        dict-modification
辞書の要素を変更したり、新しい要素を追加するには:letを使う:
        :let dict[4] = "four"
        :let dict['one'] = item

辞書から要素を取り除くにはremove():unletを使う。以下のように辞書からキー
"aaa" を取り除くには3つの方法がある:
        :let i = remove(dict, 'aaa')
        :unlet dict.aaa
        :unlet dict['aaa']

2つの辞書を併合させるにはextend()を使う:
        :call extend(adict, bdict)
上のコマンドはbdictの全ての要素をadictに追加する。キーが重複した要素はbdictの
要素により上書きされる。この動作は3番目の引数により変更できる。
Note 辞書の要素間に順序は定まっていない。そのため ":echo adict" としたとき、も
ともとadictにあった要素が先に、bdictから追加された要素が後に表示されると考えて
はならない。

辞書から条件を指定して要素を取り除くにはfilter()が使える:
        :call filter(dict, 'v:val =~ "x"')
このコマンドは "dict" から 'x' にマッチしない要素を全て取り除く。


関数を辞書に入れる
                                Dictionary-function self E725 E862
関数が "dict" 属性つきで定義されると、特殊な方法で呼び出すことができる。例:
        :function Mylen() dict
        :   return len(self.data)
        :endfunction
        :let mydict = {'data': [0, 1, 2, 3], 'len': function("Mylen")}
        :echo mydict.len()

これはオブジェクト指向プログラミングのメソッドに似ている。この辞書の要素は
Funcrefである。暗黙に定義されるローカル変数 "self" は、この関数を呼び出した
辞書を参照している。

"dict" 属性をつけないでFuncrefを辞書に入れることもできる。しかしその場合、変
数 "self" は定義されない。

                                numbered-function anonymous-function
関数に名前をつける必要をなくすために、関数を定義して直接辞書に代入することがで
きる:
        :let mydict = {'data': [0, 1, 2, 3]}
        :function mydict.len()
        :   return len(self.data)
        :endfunction
        :echo mydict.len()

こうすると関数に番号がふられ、dict.lenがこの関数を参照するFuncrefとなる。こ
の関数はFuncrefを通してのみ呼び出せる。参照しているFuncrefがなくなると、こ
の関数は自動的に削除される。

番号付き関数には "dict" 属性を付ける必要はない。

番号付き関数でエラーが発生したときは、あるトリックを使うことで発生源を確認でき
る。例えば 42 という関数なら次のようにする:
        :function {42}


辞書操作関数
                                                        E715
以下は辞書操作に使える関数である:
        :if has_key(dict, 'foo')        " 辞書がキー "foo" の要素を持つなら真
        :if empty(dict)                 " 辞書が空なら真
        :let l = len(dict)              " 辞書の要素数
        :let big = max(dict)            " 辞書中の最大値
        :let small = min(dict)          " 辞書中の最小値
        :let xs = count(dict, 'x')      " 'x' の出現回数を数える
        :let s = string(dict)           " 辞書の文字列表現
        :call map(dict, '">> " . v:val')  " 各要素の前に ">> " をつける


1.5 変数について補足
                                                        more-variables

変数や式の結果の型を知りたいのならば、関数type()を使う。

オプション 'viminfo' にフラグ '!' が含まれるならば、大文字で始まり小文字を含ま
ない名前のグローバル変数は、viminfoファイルviminfo-fileに格納される。

オプション 'sessionoptions' が "global" を含むなら、大文字で始まり少なくとも一
文字以上の小文字を含む名前のグローバル変数は、sessionファイルsession-file
格納される。

変数名                  何処に保存されるか
my_var_6                されない
My_Var_6                sessionファイル
MY_VAR_6                viminfoファイル


波括弧を使って変数名を構成できる。詳細はcurly-braces-namesを参照。

==============================================================================
2. 式の文法                                             expression-syntax

式文法一覧、優先順位の低いものから高い順に:

expr1 expr2
        expr2 ? expr1 : expr1   if-then-else 条件式

expr2 expr3
        expr3 || expr3 ..       論理和

expr3 expr4
        expr4 && expr4 ..       論理積

expr4 expr5
        expr5 == expr5          等しい
        expr5 != expr5          等しくない
        expr5 >  expr5          より大きい
        expr5 >= expr5          大きいか等しい
        expr5 <  expr5          より小さい
        expr5 <= expr5          小さいか等しい
        expr5 =~ expr5          正規表現にマッチする
        expr5 !~ expr5          正規表現にマッチしない

        expr5 ==? expr5         文字列として等しい(大文字/小文字区別無し)
        expr5 ==# expr5         文字列として等しい(大文字/小文字区別有り)
        etc.                    上記の各式は大小文字の区別を、?を付加すると行
                                わず、#を付加すると行う

        expr5 is expr5          同一の List のインスタンス
        expr5 isnot expr5       異なる List のインスタンス

expr5 expr6
        expr6 +  expr6 ..       足し算またはリストの連結
        expr6 -  expr6 ..       引き算
        expr6 .  expr6 ..       文字列の連結

expr6 expr7
        expr7 *  expr7 ..       掛け算
        expr7 /  expr7 ..       割り算
        expr7 %  expr7 ..       剰余(割った余り)

expr7 expr8
        ! expr7                 論理否定
        - expr7                 単項のマイナス {訳注: -1等}
        + expr7                 単項のプラス

expr8 expr9
        expr8[expr1]            文字列のバイト、またはリストの要素
        expr8[expr1 : expr1]    文字列の部分文字列、またはリストの部分リスト
        expr8.name              辞書 Dictionary の要素
        expr8(expr1, ...)       Funcref 変数による関数呼び出し

expr9 number                  数定数
        "string"                文字列定数。バックスラッシュは特別な意味を持つ
        'string'                リテラル文字列定数。'を含めるには2重にする
        [expr1, ...]            リスト List
        {expr1: expr1, ...}     辞書 Dictionary
        &option                 オプション変数
        (expr1)                 式の入れ子
        variable                内部変数
        va{ria}ble              波括弧付きの内部変数
        $VAR                    環境変数
        @r                      レジスタ 'r' の値
        function(expr1, ...)    関数呼出し
        func{ti}on(expr1, ...)  波括弧付きの関数呼出し
        {args -> expr1}         ラムダ式

".." はその演算が、その後に他の演算を続ける事ができることを示している。
例:
        &nu || &list && &shell == "csh"

一つのレベルにある全ての式は左から右に解釈される。


expr1                                                   expr1 E109
-----

expr2 ? expr1 : expr1

'?' より前の式は数値として評価される。その結果がTRUEであった場合、'?' と ':'
に挟まれた式の値がこの式全体の値となり、そうでなかった場合は ':' 以降の式の値
が全体の値となる。
例:
        :echo lnum == 1 ? "先頭" : lnum

始めの式が "expr2" であるから、そこに別の?:を含むことはできない。残り二つの式
については以下のように再帰的な?:の利用が許される。
例:
        :echo lnum == 1 ? "top" : lnum == 1000 ? "last" : lnum

読み易くするために、行継続line-continuationを利用することが推奨される:
        :echo lnum == 1
        :\      ? "top"
        :\      : lnum == 1000
        :\              ? "last"
        :\              : lnum

':' の前には必ずスペースを入れること。そうでないと "a:1" のような変数の使用と
間違えてしまう可能性がある。


expr2 and expr3                                         expr2 expr3
---------------

expr3 || expr3 ..       論理和          expr-barbar
expr4 && expr4 ..       論理積          expr-&&

演算子 "||" と "&&" は左右に一つずつ引数を取る。引数は数値に変換される。結果は:

    入力                         出力
n1      n2              n1 || n2        n1 && n2
FALSE FALSE         FALSE         FALSE
FALSE TRUE          TRUE          FALSE
TRUE  FALSE         TRUE          FALSE
TRUE  TRUE          TRUE          TRUE

演算子は続けて書く事ができる。例:

        &nu || &list && &shell == "csh"

Note "&&" は "||" よりも高い優先順位を持っている。これは次の事を意味する:

        &nu || (&list && &shell == "csh")

結果が確定した時点で残りの式は省略され、解釈されない。これはC言語で行われるこ
とに似ている。例:

        let a = 1
        echo a || b

これはaがTRUEであるため、変数bが宣言されていなくても有効であり、結果は絶対
TRUEである。次のも同様に:

        echo exists("b") && b == "yes"

これもbが宣言されているいないに関わらず有効である。後半の項はbが定義されている
時にだけ評価される。


expr4                                                   expr4
-----

expr5 {cmp} expr5

2つの式expr5を比較し、結果が偽なら0を、真なら1を返す。

                        expr-==  expr-!=  expr->   expr->=
                        expr-<   expr-<=  expr-=~  expr-!~
                        expr-==# expr-!=# expr->#  expr->=#
                        expr-<#  expr-<=# expr-=~# expr-!~#
                        expr-==? expr-!=? expr->?  expr->=?
                        expr-<?  expr-<=? expr-=~? expr-!~?
                        expr-is expr-isnot expr-is# expr-isnot#
                        expr-is? expr-isnot?
                'ignorecase'次第   大小文字考慮    大小文字無視
等しい                  ==              ==#             ==?
等しくない              !=              !=#             !=?
より大きい              >               >#              >?
より大きいか等しい      >=              >=#             >=?
より小さい              <               <#              <?
より小さいか等しい      <=              <=#             <=?
正規表現マッチ          =~              =~#             =~?
正規表現非マッチ        !~              !~#             !~?
同一のインスタンス      is              is#             is?
異なるインスタンス      isnot           isnot#          isnot?

例:
"abc" ==# "Abc"   0と評価される
"abc" ==? "Abc"   1と評価される
"abc" == "Abc"    'ignorecase' が設定されていれば1と、でなければ0と評価

                                                        E691 E692
リストListはリストとだけ比較可能で、==系、!=系、is、isnotのみ利用できる。
これらはそれぞれのリストの値を再帰的に比較する。大文字小文字無視にすると要素を
比較するときに大文字小文字を無視する。

                                                        E735 E736
辞書Dictionaryは辞書とだけ比較可能で、==系、!=系、is、isnotのみ利用できる。
これらは辞書のキー/値を再帰的に比較する。大文字小文字無視にすると要素を
比較するときに大文字小文字を無視する。

                                                        E694
FuncrefFuncrefとだけ比較可能で、"equal", "not equal", "is", "isnot" のみ
利用できる。大文字小文字は常に区別される。引数や辞書が(部分適用に)バインドされ
ているかどうかも重要である。辞書も同値(あるいは "is" の場合は同一)でなければな
らず、引数も同値(あるいは同一)でなければならない。

関数参照が同じ関数を指しているのかを、バインドされた辞書や引数を無視して比較し
たい場合は、get() を使用して関数名を取得すればよい:
        if get(Part1, 'name') == get(Part2, 'name')
           " Part1 と Part2 は同じ関数を指している

リスト (List) や 辞書 (Dictionary) に対して "is" や "isnot" を使うと、それ
らの式が同じリストのインスタンスを参照しているか判定される。リストのコピーと元
のリストは異なると判定される。リスト以外に対して "is" は "equal" と同じで、
"isnot" は "not equal" と同じである。ただし "is"、"isnot" は型が異なると値が等
しくない点が "==" とは異なる。
        echo 4 == '4'
        1
        echo 4 is '4'
        0
        echo 0 is []
        0
"is#"/"isnot#" と "is?"/"isnot?" は大文字小文字を区別するかどうかが違う。

文字列と数値を比較した場合、文字列が数値に変換され、数値として比較される。これ
は以下のようになることを意味する:
        echo 0 == 'x'
        1
なぜなら、'x' は数値のゼロに変換されるからである。しかし、
        echo [0] == ['x']
        0
リストや辞書の中ではこの変換は行われない。

文字列同士を比較した場合、strcmp()やstricmp()によって比較される。これは数値的
に(バイトの値で)比較されるのであって、必ずしも言語に基づく文字種の違いではな
い。

'#' を付けた演算子を使うか、省略形かつ 'ignorecase' が設定されていない場合、比
較はstrcmp()で行われる。大文字・小文字は区別される。

'?' を付けた演算子を使うか、省略形かつ 'ignorecase' が設定されている場合、比較
はstricmp()で行われる。大文字・小文字は区別されない。

'smartcase' は適用されない。

"=~" と "!~" 演算子は右側の引数を正規表現のパターンとして、左側の引数に対して
マッチを試みる。正規表現のパターンに関してはpatternを参照。このマッチは
'magic' が設定され 'cpoptions' が空であるように振舞い、実際の 'magic' や
'cpoptions' に何が設定されているには依存しない。これがスクリプトをポータブルに
してくれる。正規表現中のバックスラッシュが重複してしまうのを避けるには、シング
ルクォーテーションの文字列を使用する。詳細はliteral-stringを参照。
文字列は単一行として扱われるので、複数行のパターン(\nを含むもの)はマッチしな
い。しかしながらリテラルなヌル文字(NL)を、普通の文字として代用することはでき
る。例:
        "foo\nbar" =~ "\n"      1として評価される
        "foo\nbar" =~ "\\n"     0として評価される


expr5 and expr6                                         expr5 expr6
---------------
expr6 +  expr6 ..       足し算、またはリストの連結      expr-+
expr6 -  expr6 ..       引き算                          expr--
expr6 .  expr6 ..       文字列の連結                    expr-.

リストに対しては "+" のみ可能で、expr6は両方ともリストでなければならない。結果
は2つのリストを連結した新しいリスト。

expr7 *  expr7 ..       掛け算                                  expr-star
expr7 /  expr7 ..       割り算                                  expr-/
expr7 %  expr7 ..       剰余(割った余り)                        expr-%

"." を除く全ての演算子は自動的に文字列を数値に変換する。
ビット演算については and()or()xor() を参照。

"+" と "." の違いに注意:
        "123" + "456" = 579
        "123" . "456" = "123456"

'.' は '+' と '-' と等しい優先順位を持つので、次の式は:
        1 . 90 + 90.0
次のように解釈される:
        (1 . 90) + 90.0
これはエラーにならない。というのは、"190" は自動的に数値 190 に変換さ
れ、それと浮動小数点数 90.0 との和になる。しかし次の式は:
        1 . 90 * 90.0
次のように解釈される:
        1 . (90 * 90.0)
'.' は '*' より優先順位が低いためである。これはエラーになる。というのは、浮動
小数点数と文字列を結合することになるからである。

数値をゼロで割った結果は、被除数によって次のようになる:
          0 / 0  = -0x80000000  (浮動小数点数の NaN のようなもの)
         >0 / 0  =  0x7fffffff  (正の無限大のようなもの)
         <0 / 0  = -0x7fffffff  (負の無限大のようなもの)
        {訳注: >0 は正の数、<0 は負の数の意味}
        (Vim 7.2 以前では常に 0x7fffffff だった)

64ビット数値が有効化されている場合は:
          0 / 0  = -0x8000000000000000  (浮動小数点数の NaN のようなもの)
         >0 / 0  =  0x7fffffffffffffff  (正の無限大のようなもの)
         <0 / 0  = -0x7fffffffffffffff  (負の無限大のようなもの)

'%' の右辺(法)が0の場合、結果は0になる。

これらは全てFuncrefには適用できない。

. と % は浮動小数点数には適用できない。 E804


expr7                                                   expr7
-----
! expr7                 論理否定                expr-!
- expr7                 単項マイナス            expr-unary--
+ expr7                 単項プラス              expr-unary-+

'!' 演算子ではTRUEFALSEに、FALSETRUEになる。
'-' では数値の符号が反転される。
'+" では変化はない。

文字列はまず数値に変換される。

これら2つは繰り返したり混ぜたりできる。例:
        !-1         == 0
        !!8         == 1
        --9         == 9


expr8                                                   expr8
-----
expr8[expr1]            文字列またはリストの要素        expr-[] E111
                                                        E909 subscript
expr8が数値か文字列ならば、この値は文字列 expr8 の第 expr1 番目のバイトからな
る 1 バイトの文字列となる。expr8は文字列、expr1は数として扱われる。ただし
expr8 がマルチバイト文字列である場合、この値は単なるバイトコードであり、1文字
とはならないかもしれないことに注意。マルチバイト文字列に対する代替方法は
byteidx() を参照するか、split()を使って文字列を文字のリストに変換すれば良
い。

インデックスが0の場合、先頭のバイトが得られることに注意。これはC言語のように働
く。注意:カラム番号は1から始まる。例えばカーソルの下のバイトを得るためには、次
のようにする必要がある:
        :let c = getline(".")[col(".") - 1]

文字列の長さよりも大きなインデックスが指定された場合、結果は空文字列になる。負
数のインデックスを指定すると、結果は常に空文字列になる(後方互換性のため)。
最後のバイトを得るには[-1:]を使うこと。

expr8がリストListならばインデックスexpr1の要素が返る。取りうるインデックスの
値についてはlist-indexを参照。インデックスが範囲を超えている場合はエラーとな
る。例:
        :let item = mylist[-1]          " 最後の要素を取得

一般的には、インデックスが正でリストの長さ以上または、負でリストの長さ×-1より
小さいときエラーとなる。


expr8[expr1a : expr1b]  部分文字列または部分リスト      expr-[:]

expr8が数値か文字列ならば、expr1aバイトからexpr1bバイトまでの部分文字列となる
(両端を含む)。expr8は文字列として扱われ、expr1aとexpr1bは数値として扱われる。
Note マルチバイトのエンコーディングは認識しない。マルチバイト文字列のイン
デックスを計算する方法については byteidx() を参照。

expr1aが省略されたときは0となる。expr1bが省略されたときは文字列の長さ-1となる。

負数のインデックスを使うことによって文字列の末尾から取り出すことができる。-1は
最後の文字、-2は最後から2文字目…を表す。

インデックスがその文字の範囲外に出てしまったときは、その文字は省かれる。expr1b
がexpr1aより小さいときは空文字列となる。

例:
        :let c = name[-1:]              " 文字列の最後のバイト
        :let c = name[-2:-2]            " 文字列の最後から2バイト目
        :let s = line(".")[4:]          " 5バイト目から末尾まで
        :let s = s[:-3]                 " 最後の2文字を削除する

                                                        slice
expr8がリストならば、インデックスexpr1aとexpr1bの間の要素からなる新しいリスト
となる。すぐ上で説明した文字列の場合と同様である。部分リストsublistも参照の
こと。例:
        :let l = mylist[:3]             " 最初の4個の要素
        :let l = mylist[4:4]            " 1個の要素からなるリスト
        :let l = mylist[:]              " リストの浅いコピー

Funcrefに対してexpr8[expr1]やexpr8[expr1a : expr1b]を使うとエラーになる。

部分リストでスコープと変数に続くコロンとの混乱に注意してください:
        mylist[n:]     " 変数nは使える
        mylist[s:]     " スコープs:を使うとエラー!


expr8.name              辞書Dictionaryの要素          expr-entry

expr8が辞書Dictionaryのとき、ドットをつけるとその後に書かれた名前が辞書の
キーと見なされる。例: expr8[name]。

名前は変数名と同じようにアルファベットと数字だけから構成されなければならない
が、数字で始まってもよい。波括弧は使えない。

ドットの前後に空白があってはならない。

例:
        :let dict = {"one": 1, 2: "two"}
        :echo dict.one
        :echo dict .2

Note ドットは文字列連結にも使われる。混乱を避けるために、文字列連結のドットの
周りには必ずスペースを入れること。


expr8(expr1, ...)       Funcref 関数呼び出し

expr8がFuncref型の変数のとき、その参照する関数を呼び出す。



                                                        expr9

------
number                  数定数                          expr-number
                                hex-number octal-number binary-number

10進数、16進数(0xか0Xで始まる)、2進数(0bか0Bで始まる)、もしくは8進数(0で始まる)
の数定数。

                                                floating-point-format
浮動小数点数は次の2つの形式で書ける:

        [-+]{N}.{M}
        [-+]{N}.{M}[eE][-+]{exp}

ここで {N} と {M} は数値である。{N} と {M} の両方とも省略してはならず、数値の
みを含めることができる。
[-+] は、省略可能なプラスまたはマイナス記号である。
{exp} は指数で、10 のベキ。
現在のロケールが何であれ、小数点にはドットのみを使える。コンマは使えない。
{+float 機能つきでコンパイルされたときのみ有効}

例:
        123.456
        +0.0001
        55.0
        -0.123
        1.234e03
        1.0E-6
        -3.1416e+88

次のものは無効である:
        3.              {M} が空
        1e40            .{M} がない

                                                        float-pi float-e
コピー&ペーストしておくのに便利な値:
        :let pi = 3.14159265359
        :let e  = 2.71828182846

論理的根拠:
浮動小数点数が導入される前は、123.456 と書くと 123 と 456 の2つの数値と解釈
され、それらが文字列に変換されて結合されて "123456" という文字列になった。
これは無意味であり、Vim script 内で意図的に使われているものが見つからなかった
ので、浮動小数点数の普通の表記法を用いるため、この後方非互換性は許容された。

                                                floating-point-precision
浮動小数点数の精度と範囲は、Vim とリンクしたライブラリの "double" の意味によ
る。実行時にこれを変更することはできない。

浮動小数点数 Float は printf("%g", f) とするのと同様に、小数点以下6桁まで表
示される。表示する桁数は printf() を使えば変えられる。例:
        :echo printf('%.15e', atan(1))
        7.853981633974483e-01



文字列                                  string String expr-string E114
------
"string"                文字列定数              expr-quote

ダブルクォートが使われていることに注意。

文字列定数には以下の特殊文字が使用できる:
\...    3桁の8進数字 (例 "\316")
\..     2桁の8進数字 (非数字が続かなければならない)
\.      1桁の8進数字 (非数字が続かなければならない)
\x..    2桁の16進数字 (例 "\x1f")
\x.     1桁の16進数字 (16進数字でないものが続かなければならない)
\X..    \x..に同じ
\X.     \x.に同じ
\u....  文字を4桁の16進数で表現したもので、実際の値は現在の 'encoding' の値に
        依存する (例えば "\u02a4")
\U....  \u と同じだが8桁までの16進数が使える
\b      バックスペース <BS>
\e      エスケープ <Esc>
\f      フォームフィード <FF>
\n      改行 <NL>
\r      改行(キャリッジリターン) <CR>
\t      タブ <Tab>
\\      円記号(バックスラッシュ)
\"      ダブルクォート
\<xxx>  "xxx" という名の特殊キー。 例 "\<C-W>" は CTRL-W。これはマップで使うた
        めのものであり、0x80 バイトはエスケープされる。
        ダブルクォート文字を使う場合はエスケープしなければならない: "<M-\">"
        utf-8 文字を得るためには <Char-xxxx> を使わずに、上述の \uxxxx を使う
        こと。

Note "\xff" は値255の1バイトとなる。これはエンコーディングによっては無効な値か
もしれない。現在の 'encoding' の値に応じた文字255を得るには "\u00ff" を使う。

Note "\000" と "\x00" は強制的に文字列の終端として扱われる。


リテラル文字列                                          literal-string E115
--------------
'string'                文字列定数              expr-'

Note シングルクォートが使われていることに注意。

この文字列は文字通りに扱われる。バックスラッシュは取り除かれないし、また特別な
意味を持ったりもしない。唯一の例外は、2つのシングルクォートで1つのシングル
クォートになることである。

シングルクォートの文字列は、バックスラッシュを2重にしなくてよいため、正規表現
パターンを表すのに便利である。以下の2つのコマンドは同値である:
        if a =~ "\\s*"
        if a =~ '\s*'


オプション                                      expr-option E112 E113
---------
&option                 オプション変数、ローカルなものが優先
&g:option               グローバルオプション変数
&l:option               ローカルオプション変数

例:
        echo "タブストップは " . &tabstop . " です"
        if &insertmode

ここにはあらゆるオプション名を使うことができる。optionsを参照。ローカル変数
を使おうとして、実際にはバッファローカルもウィンドウローカルも存在しない場合に
は、グローバル変数が利用される。


レジスタ                                                expr-register @r
--------
@r                      レジスタ 'r' の値

名前付きレジスタの中身を1つの文字列として得る。必要なところには改行文字が挿入
されている。無名レジスタの中身を取得するには@"か@@を使う。利用可能なレジスタの
説明についてはregistersを参照。

レジスタ '=' を使うと、式の値でなく式そのものを得る。それを評価するには
eval()を使う。


入れ子                                                  expr-nesting E110
-------
(expr1)                 式の入れ子


環境変数                                                expr-env
--------
$VAR                    環境変数

環境変数の文字列。定義されていない環境変数を指定した場合、結果は空文字列。
                                                        expr-env-expand
Note $VARを直接使用した場合とexpand("$VAR")を使用した場合では、動作に違いがあ
ることに注意。直接使用した場合には、現在のVimのセッション中で既知の値に展開さ
れるだけである。expand()を使用した場合、まず最初にVimのセッション中で既知の値
に展開される。それが失敗した場合、変数の展開にシェルが使用されることになる。こ
れは遅くはなるが、シェルの知りうる全ての変数を展開することができる。例:
        :echo $shell
        :echo expand("$shell")
最初の一つは恐らく何も返ってこず、2つ目は $shell の値が返ってくるだろう (貴方
のシェルがそれをサポートしているなら)


内部変数                                                expr-variable
--------
variable                内部変数
以下のinternal-variablesを参照。


関数呼出                expr-function E116 E118 E119 E120
--------
function(expr1, ...)    関数呼出
以下のfunctionsを参照。


ラムダ式                                        expr-lambda lambda
--------
{args -> expr1}         ラムダ式

ラムダ式は、expr1 を評価した結果を返す新しい無名関数を作成する。ラムダ式は以
下の点がユーザー定義関数user-functionsと異なる:

1. ラムダ式の本体は単一の式expr1であり、Exコマンド列ではない。
2. 引数に前置詞 "a:" を使用しない。例:
        :let F = {arg1, arg2 -> arg1 - arg2}
        :echo F(5, 2)
        3

引数は任意である。例:
        :let F = {-> 'error function'}
        :echo F()
        error function
                                                        closure
ラムダ式は外側のスコープの変数と引数にアクセスできる。これはよくクロージャと呼
ばれる。以下の例ではラムダの中で "i" と "a:arg" が使われているが、これらは関数
のスコープに存在する。これらは関数から抜けても有効であり続ける:
        :function Foo(arg)
        :  let i = 3
        :  return {x -> x + i - a:arg}
        :endfunction
        :let Bar = Foo(4)
        :echo Bar(6)
        5

:func-closureも参照。ラムダとクロージャのサポートは以下のように判定できる:
        if has('lambda')

sort()map()filter()とともにラムダ式を使う例:
        :echo map([1, 2, 3], {idx, val -> val + 1})
        [2, 3, 4]
        :echo sort([3,7,2,1,4], {a, b -> a - b})
        [1, 2, 3, 4, 7]

ラムダ式は、チャンネル、ジョブ、タイマーを使う際にも有用である:
        :let timer = timer_start(500,
                        \ {-> execute("echo 'Handler called'", "")},
                        \ {'repeat': 3})
        Handler called
        Handler called
        Handler called

Note Exコマンドを実行するためにどのように execute() を使っているかに注意。
醜いが。


ラムダ式は '<lambda>42' のような内部名を持っている。もしラムダ式でエラーが発生
した場合には、以下のコマンドでどのラムダ式でエラーが起きたかを調べることができ
る:
        :function {'<lambda>42'}
numbered-functionも参照。

==============================================================================
3. 内部変数                                     internal-variables E461

内部変数の名前には文字と、数字とアンダーバー('_')を使うことができる。しかし数
字で始めることはできない。波括弧を使うこともできる。
詳細はcurly-braces-namesを参照。

内部変数は ":let" コマンドで作成される :let。":unlet" コマンドで明示的に内部
変数を破棄することができる :unlet。内部変数に使われてない名前か、既に破棄さ
れた内部変数を使うとエラーとなる。

変数には幾つもの名前空間が存在する。実際にどれが利用されるかは、どのような前置
子が使われたかで決まる:

                (無し) 関数の中では関数ローカル、それ以外ではグローバル
buffer-variable    b:   現在のバッファにローカル
window-variable    w:   現在のウィンドウにローカル
tabpage-variable   t:   現在のタブページにローカル
global-variable    g:   グローバル
local-variable     l:   関数にローカル
script-variable    s:   :sourceされたVim scriptにローカル
function-argument  a:   関数の引数(関数内のみ)
vim-variable       v:   グローバル、Vimがあらかじめ定義

これらのスコープそのものに辞書を通じてアクセスできる。例えば、全てのスクリプト
ローカル変数を削除するには次のようにする:
        :for k in keys(s:)
        :    unlet s:[k]
        :endfor

                                                buffer-variable b:var b:
"b:" で始まる変数名は、カレントバッファに局所的な変数を意味する。このように一
つ一つのバッファ毎に、変数 "b:foo" を別々に使用することができる。この種の変数
はバッファが掃除(wipe out)された時や、":bdelete" で削除された時に一緒に削除さ
れる。

1つのバッファローカル変数が定義済:
                                        b:changedtick changetick
b:changedtick   現在のバッファに対する総変更の回数。変更を行うたびに増加する。
                これには一回のアンドゥ操作もカウントされる。この変数はバッファ
                に変更が行われた際にだけアクションを起こしたい時に利用できる。
                例:
                    :if my_changedtick != b:changedtick
                    :   let my_changedtick = b:changedtick
                    :   call My_Update()
                    :endif
                b:changedtick 変数を変更したり削除することはできない。

                                                window-variable w:var w:
"w:" で始まる変数名は、カレントウィンドウにローカルな変数を意味する。これはウィ
ンドウを閉じるときに破棄される。

                                                tabpage-variable t:var t:
"t:" で始まる変数名は、カレントタブページにローカルな変数を意味する。これはタ
ブページを閉じるときに破棄される。{+windows 機能つきでコンパイルしたときのみ
利用可能}

                                                global-variable g:var g:
関数の中からグローバル変数へアクセスするには、"g:" を付けた名前を使用する。こ
れが省略された場合は関数ローカルな変数にアクセスする。ただし "g:" 自体は、関数
の外でも使うことができる。

                                                local-variable l:var l:
関数の中からそのローカル変数にアクセスするには何も前置しなければ良い。明示的
に "l:" を付けることも可能である。ただし "l:" をつけないと予約されている変数名
と衝突してしまうことがある。例: "count" とすると "v:count" を参照してしまう。
"l:count" とすればローカル変数countを参照できる。

                                                script-variable s:var
Vim script 内では "s:" で始まる変数名を使うことができる。これはスクリプトに
ついてローカルであり、スクリプトの外部からはアクセスできない。

スクリプト変数は次の場所で使える:
- そのスクリプトをsourceしている間に実行されるコマンド
- そのスクリプト内で定義される関数
- そのスクリプト内で定義されるオートコマンド
- そのスクリプト内で定義される関数やオートコマンドで定義される関数やオートコマ
  ンド(再帰的)
- そのスクリプト内で定義されるユーザー定義コマンド
次の場面では使えない:
- そのスクリプトからsourceされる他のスクリプト
- マッピング
- メニュー
- など。

グローバル変数との衝突を避けるにはスクリプト変数を使う。
次の例を参照:

        let s:counter = 0
        function MyCounter()
          let s:counter = s:counter + 1
          echo s:counter
        endfunction
        command Tick call MyCounter()

ここで他のスクリプトから "Tick" を実行してみると、そのスクリプト内の変数
"s:counter" は変化せず、"Tick" が定義されたスクリプト内の "s:counter" だけが変
化する。

これと同じことをするもう1つの例:

        let s:counter = 0
        command Tick let s:counter = s:counter + 1 | echo s:counter

関数呼び出しやユーザー定義コマンドを実行するとき、スクリプト変数のコンテキスト
はその関数、コマンドが定義されたスクリプトとなる。

関数の中で関数を定義した場合、スクリプト変数も共有される。例:

        let s:counter = 0
        function StartCounting(incr)
          if a:incr
            function MyCounter()
              let s:counter = s:counter + 1
            endfunction
          else
            function MyCounter()
              let s:counter = s:counter - 1
            endfunction
          endif
        endfunction

このStartCounting()を呼ぶと、カウントアップかカウントダウンのどちらかを行う関
数MyCounter()を定義する。StartCounting()がどこで呼ばれたかに関係なく、
MyCounter()の中では変数s:counterにアクセスできる。

同じスクリプトが再度読み込まれた場合、同一のスクリプト変数が使われる。スクリプ
ト変数はVimが終了するまで存続する。以下の例はカウンタを保持する:

        if !exists("s:counter")
          let s:counter = 1
          echo "script executed for the first time"
        else
          let s:counter = s:counter + 1
          echo "script executed " . s:counter . " times now"
        endif

Note これはつまり、ファイルタイププラグインはバッファごとにスクリプト変数を1セッ
ト持つのではないということを意味する。そのような目的にはバッファローカル変数
b:varを使うこと。


Vimの定義済変数:                                vim-variable v:var v:

                                        v:beval_col beval_col-variable
v:beval_col     マウスポインタがある桁の桁番号。v:beval_lnum行目のバイトイン
                デックスである。オプション 'balloonexpr' を評価している最中の
                み有効。

                                        v:beval_bufnr beval_bufnr-variable
v:beval_bufnr   マウスポインタがあるバッファの番号。オプション 'balloonexpr'
                を評価している最中のみ有効。

                                        v:beval_lnum beval_lnum-variable
v:beval_lnum    マウスポインタがある行の行番号。オプション 'balloonexpr' を
                評価している最中のみ有効。

                                        v:beval_text beval_text-variable
v:beval_text    マウスポインタの下もしくは後ろにあるテキスト。Cプログラムのデ
                バッグのために有用。'iskeyword' が適用されるが、マウスポインタ
                の下より前にあるドットと "->" は含まれる。マウスポインタが ']'
                の上にあるときは、そこから対応する '[' とその前にあるテキスト
                までが含まれる。マウスポインタが1行に収まるビジュアル領域の上
                にあるときはその選択領域となる。オプション 'balloonexpr' を評
                価している最中のみ有効。

                                        v:beval_winnr beval_winnr-variable
v:beval_winnr   マウスポインタがあるウィンドウの番号。オプション 'balloonexpr'
                を評価している最中のみ有効。1番目のウィンドウの番号はゼロであ
                る(他の場所でのウィンドウ番号と異なっている)。

                                        v:beval_winid beval_winid-variable
v:beval_winid   マウスポインタがあるウィンドウのウィンドウID window-ID
                それ以外は v:beval_winnr と同様。

                                        v:char char-variable
v:char          'formatexpr' を評価しているときの引数。また、短縮入力
                :map-<expr> で <expr> を指定しているとき、タイプされた文字を
                保持する。
                これは InsertCharPre と InsertEnter イベントでも使われる。

                        v:charconvert_from charconvert_from-variable
v:charconvert_from
                変換しようとしているファイルの文字エンコーディング名。オプショ
                ン 'charconvert' を評価している最中のみ有効。

                        v:charconvert_to charconvert_to-variable
v:charconvert_to
                変換後のファイルの文字エンコーディング名。オプション
                'charconvert' を評価している最中のみ有効。

                                        v:cmdarg cmdarg-variable
v:cmdarg        2つの目的のために使われる:
                1. ファイルの読み書きコマンドに与えられる余分な引数。現在のと
                   ころ "++enc=" と "++ff=" がそれである。読み書きコマンドに対
                   するオートコマンドイベントが発生する前にこの変数が代入され
                   る。その読み書きコマンドの後に直接この変数を連結できるよう
                   に、先頭にスペースがついている。Note: ここには "+cmd" 引数
                   は含まれていない。どちらにしろそれは実行されるからである。
                2. ":hardcopy" でPostScriptファイルを印刷するとき、これが
                   ":hardcopy" への引数になる。'printexpr' の中で使うことがで
                   きる。

                                        v:cmdbang cmdbang-variable
v:cmdbang       v:cmdargと同じく読み書きコマンドを実行したとき設定される。読み
                書きコマンドに "!" が使われたときは1となり、使われていなければ
                0となる。Note オートコマンドの中でのみ利用可能なことに注意。
                ユーザー定義コマンドでは<bang>を使えば同じことができる。

                                v:completed_item completed_item-variable
v:completed_item
                最も最近補完された単語が含まれたcomplete-itemsDictionary
                がCompleteDoneイベント後に設定される。補完に失敗した時、その
                Dictionaryは空である。

                                        v:count count-variable
v:count         最後に実行されたノーマルモードコマンドに渡されたコマンドの実行
                回数を返す。読出し専用。使用例:
        :map _x :<C-U>echo "the count is " . v:count<CR>
                Note<C-U>は、カウントの後に ':' をタイプした時に示される行範
                囲指定を削除するために必要となる。
                "3d2w" のようにカウントが2個指定された場合、その数が掛けられる。
                よって "d6w" となる。
                オプション 'formatexpr' を評価するためにも使われる。
                また "count" は、以前の版のVimとの互換性の為に動作する。

                                        v:count1 count1-variable
v:count1        "v:count" と同じように、しかしカウントが指定されなかった時の省
                略値として存在する。

                                                v:ctype ctype-variable
v:ctype         文字に関する実行環境の現在のロケール設定。これを使えばVim
                script内で現在のロケール設定に対応できるようになる。技術的な詳
                細: LC_CTYPEに等しい。ロケールを使用していないときは "C"になる。
                この変数を設定するには:languageコマンドを使うこと。直接設定
                することはできない。
                multi-langを参照。

                                        v:dying dying-variable
v:dying         通常時は0。致命的なシグナルを受信したとき1が代入される。複数
                のシグナルを受信すると値が増加していく。オートコマンド内でVim
                が正常に終了するかチェックするために使える。{Unix でのみ動作}
                例:
        :au VimLeave * if v:dying | echo "\nAAAAaaaarrrggghhhh!!!\n" | endif

                Note: v:dying が 1 のときに別の致命的なシグナルを受信した場合
                は VimLeave 自動コマンドは実行されない。

                                        v:errmsg errmsg-variable
v:errmsg        最後に表示されたエラーメッセージ。この変数は代入することが許
                されている。例:
        :let errmsg = ""
        :next
        :if (errmsg != "")
        :  ...
                また "errmsg" は、以前の版のVimとの互換性の為に動作する。

                                        v:errors errors-variable
v:errors        assert_true()のような、テスト用関数によって見つかったエラー。
                これは文字列のリストである。
                テスト用関数はテストに失敗した時にエラーを末尾に追加する。
                古い結果を削除する方法はこの変数を空にする:
        :let v:errors = []
                たとえv:errors にリスト以外のいかなる値をセットしたとしても、
                (次に実行される時に)テスト用関数によって空のリストが設定(上書
                き)される。

                                        v:exception exception-variable
v:exception     最も直近に捕捉され、まだ終了していない例外の値。
                v:throwpointthrow-variablesを参照。
                例:
        :try
        :  throw "oops"
        :catch /.*/
        :  echo "caught" v:exception
        :endtry
                出力: "caught oops".

                                        v:false false-variable
v:false         数値0。JSONでは "false" として使われる。json_encode()を参照。
                文字列として使われた時、これは "v:false" として評価される。
                        echo v:false
                        v:false
                これは eval() がその文字列をパースしたときに、元の値に戻せるよ
                うにするためである。読出し専用。

                                        v:fcs_reason fcs_reason-variable
v:fcs_reason    FileChangedShellイベントが発生した理由。オートコマンドの中で
                何をすべきかやv:fcs_choiceに何を代入すべきかを決めるために使う。
                値は次のどれかとなる:
                        deleted         もはやファイルが存在しない
                        conflict        ファイルの内容、モード、タイムスタンプ
                                        が変化しており、バッファが変更されてい
                                        る状態。
                        changed         ファイルの内容が変化している
                        mode            ファイルのモードが変化している
                        time            タイムスタンプだけが変化している

                                        v:fcs_choice fcs_choice-variable
v:fcs_choice    FileChangedShellイベントが発生した後に何をすべきかを表す。
                オートコマンドの中で、そのバッファに対して何をすべきかを指示す
                るために使う。
                        reload          バッファを読み直す(バッファが削除され
                                        ている場合には効果がない)。
                        ask             何をすべきかをユーザーに問い合わせる。
                                        これはこのオートコマンドがない場合と同
                                        じである。ただしタイムスタンプだけが変
                                        化しているときは何もしない。
                        <empty>         何もしない。オートコマンドの中だけで必
                                        要なことは全て行ってしまっているという
                                        場合にこの値を代入する。
                既定値は<empty>。これら以外の(無効な)値が代入されたときは空の
                ときと同じ動作になり、警告メッセージは表示されない。

                                        v:fname_in fname_in-variable
v:fname_in      入力ファイルの名前。以下のオプションを評価している最中のみ
                有効:
                        オプション      このファイル名の意味
                        'charconvert'   変換するファイル
                        'diffexpr'      元のファイル
                        'patchexpr'     元のファイル
                        'printexpr'     印刷するファイル
                また、オートコマンドイベントSwapExistsが発生したときスワップ
                ファイル名が代入される。

                                        v:fname_out fname_out-variable
v:fname_out     出力ファイルの名前。以下のオプションを評価している最中のみ
                有効:
                        オプション      このファイル名の意味
                        'charconvert'   変換した結果のファイル (*)
                        'diffexpr'      diffの出力
                        'patchexpr'     パッチを当てた結果のファイル
                (*) 書き込みコマンド(":w file" など)を実行する際の変換では
                v:fname_inと同じになる。読み込みコマンド(":e file" など)を実行
                する際の変換では一時ファイル名になり、v:fname_inと異なる。

                                        v:fname_new fname_new-variable
v:fname_new     新しい方のファイル名。'diffexpr' を評価している最中のみ有効。

                                        v:fname_diff fname_diff-variable
v:fname_diff    diff(patch)ファイルの名前。'patchexpr' を評価している最中のみ
                有効。

                                        v:folddashes folddashes-variable
v:folddashes    'foldtext' 用。閉じた折り畳みのレベルを表すダッシュ。
                サンドボックスsandboxの中では読出し専用。fold-foldtext

                                        v:foldlevel foldlevel-variable
v:foldlevel     'foldtext' 用。閉じた折り畳みのレベル。
                サンドボックスsandboxの中では読出し専用。fold-foldtext

                                        v:foldend foldend-variable
v:foldend       'foldtext' 用。閉じた折り畳みの最後の行。
                サンドボックスsandboxの中では読出し専用。fold-foldtext

                                        v:foldstart foldstart-variable
v:foldstart     'foldtext' 用。閉じた折り畳みの最初の行。
                サンドボックスsandboxの中では読出し専用。fold-foldtext

                                        v:hlsearch hlsearch-variable
v:hlsearch      検索による強調表示がオンになっているかどうかを示す変数。
                設定は +extra_search 機能が必要な 'hlsearch' が有効になって
                いる時のみ意味をなす。この変数を0に設定することは、
                :nohlsearchコマンドを実行することと同様に働き、1に設定するこ
                とは以下と同様に働く
                        let &hlsearch = &hlsearch
                関数から戻ったときに値が復元されることに注意すること。
                function-search-undo

                                        v:insertmode insertmode-variable
v:insertmode    オートコマンドイベントInsertEnterInsertChange用。
                値は次のどれか:
                        i       挿入モード
                        r       置換モード
                        v       仮想置換モード

                                                v:key key-variable
v:key           辞書Dictionaryの現在の要素のキー。map()filter()で使わ
                れる式を評価している最中のみ有効。
                読出し専用。

                                                v:lang lang-variable
v:lang          メッセージに関する実行環境の現在のロケール設定。これを使えば
                Vim script内で現在のロケール設定に対応できるようになる。
                技術的な詳細: LC_MESSAGESに等しい。この値はシステムに依存する。
                この変数を設定するには:languageコマンドを使うこと。直接設定
                することはできない。
                文字エンコーディングに使うのと違う言語でメッセージを表示させた
                い場合はv:ctypeと異なる値でもよい。multi-langを参照。

                                                v:lc_time lc_time-variable
v:lc_time       時刻のメッセージに関する実行環境の現在のロケール設定。これを使
                えばVim script内で現在のロケール設定に対応できるようになる。
                技術的な詳細: LC_TIMEに等しい。この値はシステムに依存する。こ
                の変数を設定するには:languageコマンドを使うこと。直接設定す
                ることはできない。

                                                v:lnum lnum-variable
v:lnum          'foldexpr' fold-expr と 'indentexpr' に使うための行番号。ま
                た 'guitablabel' と 'guitabtooltip' の文脈ではタブページ番号に
                なる。これらの式のどれかを評価しているときのみ有効。サンドボッ
                クス sandbox の中では読出し専用。

                                        v:mouse_win mouse_win-variable
v:mouse_win     getchar()でマウスクリックイベントが発生したときのウィンドウ
                番号。winnr()と同じく番号は1から始まる。マウスがクリックされ
                なかったときは0となる。

                                        v:mouse_winid mouse_winid-variable
v:mouse_winid   getchar()でマウスクリックイベントが発生したときのウィンドウ
                ID。マウスがクリックされていないときは0になる。

                                        v:mouse_lnum mouse_lnum-variable
v:mouse_lnum    getchar()でマウスクリックイベントが発生したときの行番号。物
                理行ではなく論理行。マウスがクリックされていないときは0となる。

                                        v:mouse_col mouse_col-variable
v:mouse_col     getchar()でマウスクリックイベントが発生したときの桁番号。
                virtcol()と同じく画面上の桁番号。マウスがクリックされていな
                いときは0となる。

                                        v:none none-variable
v:none          空の文字列。JSONでは空の要素として使われる。
                json_encode()を参照。
                数値として使われた時、これは 0 として評価される。
                文字列として使われた時、これは "v:none" として評価される。
                        echo v:none
                        v:none
                これは eval() がその文字列をパースしたときに、元の値に戻せるよ
                うにするためである。読出し専用。

                                        v:null null-variable
v:null          空の文字列。JSONでは "null" として使われる。json_encode()
                参照。数値として使われた時、これは 0 として評価される。
                文字列として使われた時、これは "v:null" として評価される。
                        echo v:null
                        v:null
                これは eval() がその文字列をパースしたときに、元の値に戻せるよ
                うにするためである。読出し専用。

                                        v:oldfiles oldfiles-variable
v:oldfiles      起動時に viminfo から読み込まれたファイルの名前のリスト。
                これらはマークを記憶しているファイルである。リストの長さの上限
                はオプション 'viminfo' の引数 ' によって決まる(既定では 100)。
                viminfo ファイルが使われていない時、リストは空となる。
                :oldfiles と c_#< を参照。
                このリストは変更可能であるが、後で viminfo ファイルに書き込ま
                れるものには影響しない。文字列以外の値を使うと問題を引き起こす
                だろう。
                {+viminfo 機能つきでコンパイルされたときのみ有効}

                                                    v:option_new
v:option_new    オプションに設定された新しい値。自動コマンド OptionSet を実
                行している間のみ有効。
                                                    v:option_old
v:option_old    オプションの以前の値。自動コマンド OptionSet を実行している
                間のみ有効。
                                                    v:option_type
v:option_type   set コマンドのスコープ。自動コマンド OptionSet を実行している
                間のみ有効。"global" もしくは "local" のどちらかとなる。

                                        v:operator operator-variable
v:operator      ノーマルモードにおいて最後に実行したオペレータコマンド。基本的
                に1文字である。例外は <g> や <z> で始まるコマンドで、その場合
                は2文字になる。v:prevcount と v:register と組み合わせて使う
                とよい。オペレータ待機モードをキャンセルして、それからオペレー
                タを使いたいときに便利である。例:
                        :omap O <Esc>:call MyMotion(v:operator)<CR>
                この値は他のオペレータが入力されるまでセットされてい
                る。よって空になると期待してはいけない。
                :delete:yank などの Ex コマンドに対しては v:operator は
                セットされない。
                読出し専用。

                                        v:prevcount prevcount-variable
v:prevcount     最後のノーマルモードコマンドに与えられたカウントの値。前のコマ
                ンドのv:countの値である。ビジュアルモードやオペレータ待機モー
                ドをキャンセルし、その後にカウントを使う場合に便利である。
                例:
                        :vmap % <Esc>:call MyFilter(v:prevcount)<CR>
                読出し専用。

                                        v:profiling profiling-variable
v:profiling     通常時は0。":profile start" を実行すると1が代入される。
                profilingを参照。

                                        v:progname progname-variable
v:progname      Vimを起動したときのプログラム名(パスは除かれる)。view
                evim などの名前やシンボリックリンクなどで起動した場合に特別な
                初期化を行うのに便利。
                読出し専用。

                                        v:progpath progpath-variable
v:progpath      Vim を起動したときのコマンド (パスを含む)。--remote-expr で
                Vim サーバーにメッセージを送信するときに便利。
                フルパスを得るには:
                        echo exepath(v:progpath)
                パスが相対の場合、フルパスに展開され、これにより :cd 後でも
                機能する。例えば "./vim" で開始すると
                "/home/user/path/to/vim/src/vim" という結果になる。
                MS-Windows では実行ファイルが "vim.exe" として呼び出されるかも
                しれないが、".exe" は v:progpath には追加されない。
                読出し専用。

                                        v:register register-variable
v:register      現在のノーマルモードコマンドに適用されるレジスタの名前 (そのコ
                マンドが実際にレジスタを使うかどうかには依らない)。または、現
                在実行しているノーマルモードマッピング用のレジスタの名前 (レジ
                スタを使うカスタムコマンドの中で使う)。レジスタが指定されなかっ
                たときはデフォルトレジスタ '"' になる。'clipboard' に
                "unnamed" か "unnamedplus" が含まれているときはデフォルトはそ
                れぞれ '*' か '+' になる。
                getreg() と setreg() も参照。

                                        v:scrollstart scrollstart-variable
v:scrollstart   画面のスクロールの原因となったスクリプトや関数を説明する
                文字列。空であるときのみ代入される。よってこの変数には最初の原
                因だけが記録されている。原因がキーボードから入力されたコマンド
                の場合は "Unknown" が代入される。
                スクリプトを実行したとき現れたhit-enterプロンプトの原因を探る
                ために便利。

                                        v:servername servername-variable
v:servername    x11-clientserverに登録されている名前。
                読出し専用。


v:searchforward                 v:searchforward searchforward-variable
                検索方向: 前方検索の後なら1、後方検索の後なら0。quote/ で示す
                方法によって最終検索パターンを直接セットしたときは1(前方検索)
                にリセットされる。
                関数から戻るとき、この値は呼び出し前の値に復元される。
                function-search-undo
                読み書き両用。

                                        v:shell_error shell_error-variable
v:shell_error   最後に実行したシェルコマンドの結果。シェルコマンドの実行時に何
                かエラーがあったならば、非零の値を取る。問題がなければ零になる。
                これはシェルがエラーコードをVimに通知する時のみ働く。コマンドが
                実行されなかった時には、値として-1が良く使われる。読出し専用。
                例:
        :!mv foo bar
        :if v:shell_error
        :  echo 'could not rename "foo" to "bar"!'
        :endif
                また "shell_error" は、以前の版のVimとの互換性の為に動作する。

                                        v:statusmsg statusmsg-variable
v:statusmsg     最後に表示されたステータスメッセージ。この変数は代入すること
                が許されている。

                                        v:swapname swapname-variable
v:swapname      オートコマンドSwapExistsを実行している最中のみ有効。見つかっ
                たスワップファイルの名前。読出し専用。

                                        v:swapchoice swapchoice-variable
v:swapchoice    イベントSwapExistsにより実行されたオートコマンドが、見つかっ
                たスワップファイルをどう処理するかをこの変数に代入する。
                        'o'     読込専用で開く
                        'e'     とにかく編集する
                        'r'     復活させる
                        'd'     スワップファイルを削除する
                        'q'     終了する
                        'a'     中止する
                この変数の値は1文字の文字列でなければならない。値が空のときは
                オートコマンドSwapExistsが存在しないときと同じようにユーザーに
                問い合わせる。既定値は空。

                                        v:swapcommand swapcommand-variable
v:swapcommand   ファイルを開いた後に実行するノーマルモードコマンド。オートコマ
                ンドSwapExistsで、他のVimインスタンスにファイルを開かせ、指
                定位置までジャンプするために使うことができる。例えば、あるタグ
                へジャンプするには、この変数に ":tag tagname\r" という値を代入
                する。":edit +cmd file" を実行させるには ":cmd\r" を代入する。

                                v:t_TYPE v:t_bool t_bool-variable
v:t_bool        真偽値型の値。読出し専用。 参照: type()
                                        v:t_channel t_channel-variable
v:t_channel     チャンネル型の値。読出し専用。 参照: type()
                                        v:t_dict t_dict-variable
v:t_dict        辞書型の値。読出し専用。 参照: type()
                                        v:t_float t_float-variable
v:t_float       浮動小数点数型の値。読出し専用。 参照: type()
                                        v:t_func t_func-variable
v:t_func        Funcref型の値。読出し専用。 参照: type()
                                        v:t_job t_job-variable
v:t_job         ジョブ型の値。読出し専用。 参照: type()
                                        v:t_list t_list-variable
v:t_list        リスト型の値。読出し専用。 参照: type()
                                        v:t_none t_none-variable
v:t_none        特殊値型の値。読出し専用。 参照: type()
                                        v:t_number t_number-variable
v:t_number      数値型の値。読出し専用。 参照: type()
                                        v:t_string t_string-variable
v:t_string      文字列型の値。読出し専用。 参照: type()

                                v:termresponse termresponse-variable
v:termresponse  termcapのエントリt_RVで端末から返されるエスケープシーケン
                ス。ESC [またはCSIで始まり、途中数字と ';' と '.' だけから構成
                され 'c' で終わるエスケープシーケンスを受け取ったとき代入され
                る。このオプションがセットされるとオートコマンドイベント
                TermResponseが発生し、端末からの応答に反応することができる。
                新しいxtermからの応答は次の形式である:
                 "<Esc>[ Pp ; Pv ; Pc c"。ここでPpは端末のタイプ: 0ならvt100、
                 1ならvt220。Pvはパッチレベル(パッチ95で導入されたため常
                 に95以上)。Pcは常に0。
                {Vimが+termresponse機能付きでコンパイルされたときのみ有効}

                                        v:testing testing-variable
v:testing       test_garbagecollect_now() を使う前に設定する必要がある。
                また、これが設定されていると、特定のエラーメッセージが 2 秒間
                表示されなくなる。(例: "'dictionary' option is empty")

                                v:this_session this_session-variable
v:this_session  最後にロードされたか、セーブされたセッションファイルの完全な
                ファイル名。:mksessionを参照。この変数は代入することが許さ
                れている。それ以前にセーブされたセッションがなければ、この変数
                は空となる。
                また "this_session" は、以前の版のVimとの互換性の為に動作する。

                                        v:throwpoint throwpoint-variable
v:throwpoint    最も直近に捕捉されてまだ終了していない例外が発生した位置。キー
                ボードから入力されたコマンドは記録されていない。v:exception
                とthrow-variablesも参照。
                例:
        :try
        :  throw "oops"
        :catch /.*/
        :  echo "Exception from" v:throwpoint
        :endtry
                出力: "Exception from test.vim, line 2"

                                                v:true true-variable
v:true          数値1。JSONでは "true" として使われる。json_encode()を参照。
                文字列として使われた時、これは "v:true" として評価される。
                        echo v:true
                        v:true
                これは eval() がその文字列をパースしたときに、元の値に戻せるよ
                うにするためである。読出し専用。
                                                v:val val-variable
v:val           辞書Dictionaryの現在の要素の値。map()filter()で使わ
                れる式を評価している最中のみ有効。
                読出し専用。

                                        v:version version-variable
v:version       Vimのバージョン番号。メジャーバージョン番号は100倍され、マイ
                ナーバージョン番号と足されている。Version 5.0は500。Version
                5.1 (5.01)は501となる。読出し専用。また "version" は、以前の版
                のVimとの互換性の為に動作する。
                特定のパッチが適用されているかを調べるにはhas()を使う。例:
                        if has("patch-7.4.123")
                Note 5.0と5.1には両方ともパッチ123が存在しているが、バージョン
                が違えば番号は同じでもパッチの内容は全く異なっている。

                                v:vim_did_enter vim_did_enter-variable
v:vim_did_enter ほとんどのスタートアップが完了するまでの間 0。VimEnter 自動
                コマンドが実行される直前に 1 にセットされる。

                                        v:warningmsg warningmsg-variable
v:warningmsg    最後に表示された警告メッセージ。この変数は代入することが許され
                ている。

                                        v:windowid windowid-variable
v:windowid      X11 ベースの GUI を使っているとき、もしくは端末の Vim を使って
                いて X サーバーに接続しているとき (-X) は、ウィンドウ ID が
                セットされる。
                MS-Windows の GUI を使っているときはウィンドウハンドルがセット
                される。
                それ以外では値はゼロである。
                Note: Vim の中のウィンドウを扱うときは winnr() または
                win_getid() を使う。window-ID を参照。

==============================================================================
4. 組み込み関数                                         functions

機能別に分類された一覧は function-list を参照のこと。

(関数名の上でCTRL-]を使うことで、詳細な説明へ飛ぶことができる。)

使用法                          結果    説明

abs({expr})                     浮動小数点数または数値  {expr}の絶対値
acos({expr})                    浮動小数点数    {expr}のアークコサイン
add({list}{item})             リスト  {item}をリスト{list}に追加する
and({expr}{expr})             数値    ビット論理積
append({lnum}{string})        数値    {string}{lnum}行目に付け加える
append({lnum}{list})          数値    行{list}{lnum}行目に付け加える
argc()                          数値    引数内のファイルの数
argidx()                        数値    引数リスト内の現在のインデックス
arglistid([{winnr} [, {tabnr}]])
                                数値    引数リストID
argv({nr})                      文字列  引数の第{nr}番目
argv()                          リスト  引数リスト
assert_equal({exp}{act} [, {msg}])
                                なし    {exp}{act}が等しいかどうかテストする
assert_exception({error} [, {msg}])
                                なし    v:exception{error}であるかテストする
assert_fails({cmd} [, {error}])
                                なし    {cmd}が失敗するかどうかテストする
assert_false({actual} [, {msg}])
                                なし    {actual}がfalseかどうかテストする
assert_inrange({lower}{upper}{actual} [, {msg}])
                                なし    {actual}が範囲内にあるかテストする
assert_match({pat}{text} [, {msg}])    なし  {pat}{text}にマッチするかテス
                                        トする
assert_notequal({exp}{act} [, {msg}])  なし  {exp}{act}と等しくないことを
                                        テストする
assert_notmatch({pat}{text} [, {msg}]) なし  {pat}{text}とマッチしないこと
                                        をテストする
assert_true({actual} [, {msg}])
                                なし    {actual}がtrueかどうかテストする
asin({expr})                    浮動小数点数    {expr}のアークサイン
atan({expr})                    浮動小数点数    {expr}のアークタンジェント
atan2({expr}{expr})           浮動小数点数    {expr1} / {expr2} のアークタン
                                                ジェント
balloon_show({msg})             なし    {msg} をバルーン内に表示
browse({save}{title}{initdir}{default})
                                文字列  ファイル選択ダイアログを表示
browsedir({title}{initdir})   文字列  ディレクトリ選択ダイアログを表示
bufexists({expr})               数値    バッファ{expr}が存在すればTRUE
buflisted({expr})               数値    バッファ{expr}がリストにあるならTRUE
bufloaded({expr})               数値    バッファ{expr}がロード済みならTRUE
bufname({expr})                 文字列  バッファ{expr}の名前
bufnr({expr} [, {create}])      数値    バッファ{expr}の番号
bufwinid({expr})                数値    バッファ{expr}のウィンドウID
bufwinnr({nr})                  数値    バッファ{nr}のウィンドウ番号
byte2line({byte})               数値    {byte}番目のバイトの行番号
byteidx({expr}{nr})           数値    {expr}{nr}文字目のバイトインデックス
byteidxcomp({expr}{nr})       数値    {expr}{nr}文字目のバイトインデックス
call({func}{arglist} [, {dict}])
                                任意    引数{arglist}をつけて{func}を呼ぶ
ceil({expr})                    浮動小数点数    {expr} を切り上げる
ch_canread({handle})            数値    何か読むものがあるかをチェックする
ch_close({handle})              なし    {handle} を閉じる
ch_close_in({handle})           なし    {handle} の入力を閉じる
ch_evalexpr({handle}{expr} [, {options}])
                                任意    {handle} に {expr} を送り応答をJSONと
                                        して評価する
ch_evalraw({handle}{string} [, {options}])
                                任意    {handle} に {string} を送り応答を生の
                                        文字列として評価する
ch_getbufnr({handle}{what})   数値    {handle}/{what} に割り当てられたバッ
                                        ファ番号を得る
ch_getjob({channel})            ジョブ  {channel} の Job を得る
ch_info({handle})               文字列  チャンネル {handle} に関する情報を得る
ch_log({msg} [, {handle}])      なし    チャンネルのログファイルに {msg} を書
                                        き込む
ch_logfile({fname} [, {mode}])  なし    チャンネルの挙動ログ出力を開始する
ch_open({address} [, {options}])
                                チャンネル      {address} へのチャンネルを開く
ch_read({handle} [, {options}]) 文字列  {handle} から読み込む
ch_readraw({handle} [, {options}])
                                文字列  {handle} から生の文字列を読み込む
ch_sendexpr({handle}{expr} [, {options}])
                                任意    {expr}をJSONチャンネル{handle}に送る
ch_sendraw({handle}{string} [, {options}])
                                任意    {string}をrawチャンネル{handle}に送る
ch_setoptions({handle}{options})
                                なし    {handle}にオプションを設定する
ch_status({handle} [, {options}])
                                文字列  チャンネル{handle}の状態
changenr()                      数値    現在の変更番号
char2nr({expr}[, {utf8}])       数値    {expr}の先頭文字のASCII/UTF8コード
cindent({lnum})                 数値    {lnum}行目のCインデント量
clearmatches()                  なし    全マッチをクリアする
col({expr})                     数値    カーソルかマークのカラム番号
complete({startcol}{matches}) なし    挿入モード補完を設定する
complete_add({expr})            数値    補完候補を追加する
complete_check()                数値    補完中に押されたキーをチェックする
confirm({msg} [, {choices} [, {default} [, {type}]]])
                                数値    ユーザーへの選択肢と番号
copy({expr})                    任意    {expr}の浅いコピーを作る
cos({expr})                     浮動小数点数    {expr} の余弦(コサイン)
cosh({expr})                    浮動小数点数    {expr}のハイパボリックコサイン
count({list}{expr} [, {ic} [, {start}]])
                                数値     {list}中に{expr}が何個現れるか数える
cscope_connection([{num} , {dbpath} [, {prepend}]])
                                数値    cscope接続の存在を判定する
cursor({lnum}{col} [, {off}])
                                数値    カーソルを{lnum}{col}{off}へ移動
cursor({list})                  数値    カーソルを{list}の位置へ移動
deepcopy({expr} [, {noref}])    任意    {expr}の完全なコピーを作る
delete({fname} [, {flags}])     数値    ファイルやディレクトリ{fname}を消す
did_filetype()                  数値    FileTypeのautocommandが実行されたか?
diff_filler({lnum})             数値    差分モードで{lnum}に挿入された行
diff_hlID({lnum}{col})        数値    差分モードで{lnum}/{col}位置の強調
empty({expr})                   数値    {expr}が空ならTRUE
escape({string}{chars})       文字列  {string}内の{chars}を '\' でエスケープ
eval({string})                  任意    {string}を評価し、値を得る
eventhandler()                  数値    イベントハンドラの内側ならTRUE
executable({expr})              数値    実行可能な{expr}が存在するなら1
execute({command})              文字列  {command}を実行し、出力を得る
exepath({expr})                 文字列  コマンド {expr} のフルパス
exists({var})                   数値    変数{var}が存在したらTRUE
extend({expr1}{expr2} [, {expr3}])
                                リスト/辞書 {expr1}{expr2}の要素を挿入
exp({expr})                     浮動小数点数    {expr}の指数
expand({expr} [, {nosuf} [, {list}]])
                                任意    {expr}内の特別なキーワードを展開
feedkeys({string} [, {mode}])   数値    先行入力バッファにキーシーケンスを追加
filereadable({file})            数値    {file}が読みこみ可能ならTRUE
filewritable({file})            数値    {file}が書き込み可能ならTRUE
filter({expr1}{expr2})        リスト/辞書  {expr2}が0となる要素を{expr1}から
                                        とり除く
finddir({name}[, {path}[, {count}]])
                                文字列  {path}からディレクトリ{name}を探す
findfile({name}[, {path}[, {count}]])
                                文字列  {path}からファイル{name}を探す
float2nr({expr})                数値    浮動小数点数 {expr} を数値に変換する
floor({expr})                   浮動小数点数    {expr} を切り捨てる
fmod({expr1}{expr2})          浮動小数点数    {expr1} / {expr2} の余り
fnameescape({fname})            文字列  {fname} 内の特殊文字をエスケープする
fnamemodify({fname}{mods})    文字列  ファイル名を変更
foldclosed({lnum})              数値    {lnum}の折り畳みの最初の行(閉じている
                                        なら)
foldclosedend({lnum})           数値    {lnum}の折り畳みの最後の行(閉じている
                                        なら)
foldlevel({lnum})               数値    {lnum}の折り畳みレベル
foldtext()                      文字列  閉じた折り畳みに表示されている行
foldtextresult({lnum})          文字列  {lnum}で閉じている折り畳みのテキスト
foreground()                    数値    Vimウィンドウを前面に移動する
funcref({name} [, {arglist}] [, {dict}])
                                Funcref 関数{name}への参照
function({name} [, {arglist}] [, {dict}])
                                Funcref 名前による関数{name}への参照
garbagecollect([{atexit}])      なし    メモリを解放する。循環参照を断ち切る
get({list}{idx} [, {def}])    任意    {list}{def}から要素{idx}を取得
get({dict}{key} [, {def}])    任意    {dict}{def}から要素{key}を取得
get({func}{what})             任意    funcref/partial {func}のプロパティ取得
getbufinfo([{expr}])            リスト  バッファに関する情報
getbufline({expr}{lnum} [, {end}])
                                リスト  バッファ{expr}{lnum}から{end}行目
getbufvar({expr}{varname} [, {def}])
                                任意    バッファ{expr}の変数 {varname}
getchar([expr])                 数値    ユーザーから1文字を取得する
getcharmod()                    数値    修飾キーの状態を表す数値を取得
getcharsearch()                 辞書    最後の文字検索を取得
getcmdline()                    文字列  現在のコマンドラインを取得
getcmdpos()                     数値    コマンドラインのカーソル位置を取得
getcmdtype()                    文字列  現在のコマンドラインの種類を取得
getcmdwintype()                 文字列  現在のコマンドラインウィンドウの種類
getcompletion({pat}{type} [, {filtered}])
                                リスト  コマンドライン補完にマッチするリスト
getcurpos()                     リスト  カーソルの位置
getcwd([{winnr} [, {tabnr}]])   文字列  現在の作業ディレクトリを取得
getfontname([{name}])           文字列  使用しているフォントの名前
getfperm({fname})               文字列  ファイル{fname}の許可属性を取得
getfsize({fname})               数値    ファイル{fname}のバイト数を取得
getftime({fname})               数値    ファイルの最終更新時間
getftype({fname})               文字列  ファイル{fname}の種類の説明
getline({lnum})                 文字列  現在のバッファから行の内容を取得
getline({lnum}{end})          リスト  カレントバッファの{lnum}から{end}行目
getloclist({nr})                リスト  ロケーションリストの要素のリスト
getmatches()                    リスト  現在のマッチのリスト
getpid()                        数値    Vim のプロセス ID
getpos({expr})                  リスト  カーソル・マークなどの位置を取得
getqflist([{what}])             リスト  quickfix要素のリスト
getreg([{regname} [, 1 [, {list}]]])
                                文字列/リスト   レジスタの中身を取得
getregtype([{regname}])         文字列  レジスタの種類を取得
gettabinfo([{expr}])            リスト  タブページのリスト
gettabvar({nr}{varname} [, {def}])
                                任意    タブ{nr}の変数{varname}または{def}
gettabwinvar({tabnr}{winnr}{name} [, {def}])
                                任意    タブページ{tabnr}{winnr}{name}
getwininfo([{winid}])           リスト  ウィンドウのリスト
getwinposx()                    数値    GUI vim windowのX座標
getwinposy()                    数値    GUI vim windowのY座標
getwinvar({nr}{varname} [, {def}])
                                文字列  ウィンドウ{nr}の変数{varname}
glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])
                                任意    {expr}内のfile wildcardを展開
glob2regpat({expr})             文字列  globパターンを検索パターンに変換
globpath({path}{expr} [, {nosuf} [, {list} [, {alllinks}]]])
                                文字列  {path}の全ディレクトリに対し
                                        glob({expr})を行う
has({feature})                  数値    機能{feature}がサポートならばTRUE
has_key({dict}{key})          数値    {dict}が要素{key}を持つならTRUE
haslocaldir([{winnr} [, {tabnr}]])
                                数値    現在のウィンドウで:lcdが実行された
                                        ならTRUE
hasmapto({what} [, {mode} [, {abbr}]])
                                数値    {what}のマッピングが存在するならTRUE
histadd({history}{item})      文字列  ヒストリに追加
histdel({history} [, {item}])   文字列  ヒストリからitemを削除
histget({history} [, {index}])  文字列  ヒストリから{index}アイテムを取得
histnr({history})               数値    ヒストリの数
hlexists({name})                数値    highlight group {name}が存在したらTRUE
hlID({name})                    数値    highlight group {name}のID
hostname()                      文字列  vimが動作しているマシンの名前
iconv({expr}{from}{to})     文字列  {expr}のエンコーディングを変換する
indent({lnum})                  文字列  行{lnum}のインデントを取得
index({list}{expr} [, {start} [, {ic}]])
                                数値    {list}中に{expr}が現れる位置
input({prompt} [, {text} [, {completion}]])
                                文字列  ユーザーからの入力を取得
inputdialog({prompt} [, {text} [, {completion}]]])
                                文字列  input()と同様。GUIのダイアログを使用
inputlist({textlist})           数値    ユーザーに選択肢から選ばせる
inputrestore()                  数値    先行入力を復元する
inputsave()                     数値    先行入力を保存し、クリアする
inputsecret({prompt} [, {text}]) 文字列 input()だがテキストを隠す
insert({list}{item} [, {idx}]) リスト {list}に要素{item}を挿入 [{idx}の前]
invert({expr})                  数値    ビット反転
isdirectory({directory})        数値    {directory}がディレクトリならばTRUE
islocked({expr})                数値    {expr}がロックされているならTRUE
isnan({expr})                   数値    {expr}がNaNならばTRUE
items({dict})                   リスト  {dict}のキーと値のペアを取得
job_getchannel({job})           チャンネル  {job}のチャンネルハンドルを取得
job_info({job})                 辞書    {job}についての情報を取得
job_setoptions({job}{options}) なし   {job}のオプションを設定する
job_start({command} [, {options}])
                                ジョブ  ジョブを開始する
job_status({job})               文字列  {job}のステータスを取得する
job_stop({job} [, {how}])       数値    {job}を停止する
join({list} [, {sep}])          文字列  {list}の要素を連結して文字列にする
js_decode({string})             任意    JS形式のJSONをデコードする
js_encode({expr})               文字列  JS形式のJSONにエンコードする
json_decode({string})           任意    JSONをデコードする
json_encode({expr})             文字列  JSONにエンコードする
keys({dict})                    リスト  {dict}のキーを取得
len({expr})                     数値    {expr}の長さを取得
libcall({lib}{func}{arg}    文字列  ライブラリ{lib}の関数{func}をコール
libcallnr({lib}{func}{arg}) 数値    上と同じ。ただし数値を返す
line({expr})                    数値    行番号の取得
line2byte({lnum})               数値    行{lnum}のバイトカウント
lispindent({lnum})              数値    {lnum}行目のLispインデント量を取得
localtime()                     数値    現在時刻
log({expr})                     浮動小数点数    {expr}の自然対数(底e)
log10({expr})                   浮動小数点数    浮動小数点数 {expr} の 10 を底
                                                とする対数
luaeval({expr}[, {expr}])       任意    Lua の式を評価する
map({expr1}{expr2})           リスト/辞書  {expr1}の各要素を{expr2}に変える
maparg({name}[, {mode} [, {abbr} [, {dict}]]])
                                文字列/辞書
                                        モード{mode}でのマッピング{name}の値
mapcheck({name}[, {mode} [, {abbr}]])
                                文字列  {name}にマッチするマッピングを確認
match({expr}{pat}[, {start}[, {count}]])
                                数値    {expr}内で{pat}がマッチする位置
matchadd({group}{pattern}[, {priority}[, {id} [, {dict}]]])
                                数値    {pattern} を {group} で強調表示する
matchaddpos({group}{pos}[, {priority}[, {id}[, {dict}]]])
                                数値    位置を {group} で強調表示する
matcharg({nr})                  リスト  :matchの引数
matchdelete({id})               数値    {id} で指定されるマッチを削除する
matchend({expr}{pat}[, {start}[, {count}]])
                                数値    {expr}内で{pat}が終了する位置
matchlist({expr}{pat}[, {start}[, {count}]])
                                リスト  {expr}内の{pat}のマッチと部分マッチ
matchstr({expr}{pat}[, {start}[, {count}]])
                                文字列  {expr}内の{count}番目の{pat}のマッチ
matchstrpos({expr}{pat}[, {start}[, {count}]])
                                リスト  {expr}内の{count}番目の{pat}のマッチ
max({expr})                     数値    {expr}内の要素の最大値
min({expr})                     数値    {expr}内の要素の最小値
mkdir({name} [, {path} [, {prot}]])
                                数値    ディレクトリ{name}を作成
mode([expr])                    文字列  現在の編集モード
mzeval({expr})                  任意    MzScheme の式を評価する
nextnonblank({lnum})            数値    {lnum}行目以降で空行でない行の行番号
nr2char({expr}[, {utf8}])       文字列  ASCII/UTF8コード{expr}で示される文字
or({expr}{expr})              数値    ビット論理和
pathshorten({expr})             文字列  path内の短縮したディレクトリ名
perleval({expr})                任意    Perlの式を評価する
pow({x}{y})                   浮動小数点数    {x} の {y} 乗
prevnonblank({lnum})            数値    {lnum}行目以前の空行でない行の行番号
printf({fmt}{expr1}...)       文字列  文字列を組み立てる
pumvisible()                    数値    ポップアップメニューが表示されているか
pyeval({expr})                  任意    Python の式を評価する
py3eval({expr})                 任意    python3 の式を評価する
pyxeval({expr})                 任意    python_x の式を評価する
range({expr} [, {max} [, {stride}]])
                                リスト  {expr}から{max}までの要素のリスト
readfile({fname} [, {binary} [, {max}]])
                                リスト  ファイル{fname}から行のリストを取得
reltime([{start} [, {end}]])    リスト  時刻の値を取得
reltimefloat({time})            浮動小数点数    時刻の値を浮動小数点に変換
reltimestr({time})              文字列  時刻の値を文字列に変換
remote_expr({server}{string} [, {idvar}])
                                文字列  式を送信する
remote_foreground({server})     数値    Vimサーバーを前面に出す
remote_peek({serverid} [, {retvar}])
                                数値    返信文字列を確認する
remote_read({serverid})         文字列  返信文字列を読み込む
remote_send({server}{string} [, {idvar}])
                                文字列  キーシーケンスを送信する
remove({list}{idx} [, {end}]) 任意    {list}から{idx}{end}間の要素を削除
remove({dict}{key})           任意    {dict}から要素{key}を削除
rename({from}{to})            数値    {file}から{to}へファイル名変更
repeat({expr}{count})         文字列  {expr}{count}回繰り返す
resolve({filename})             文字列  ショートカットが指す先のファイル名
reverse({list})                 文字列  {list}をその場で反転させる
round({expr})                   浮動小数点数    {expr} を四捨五入する
screenattr({row}{col})        数値    スクリーン位置の属性
screenchar({row}{col})        数値    スクリーン位置の文字
screencol()                     数値    現在のカーソル列
screenrow()                     数値    現在のカーソル行
search({pattern} [, {flags} [, {stopline} [, {timeout}]]])
                                数値    {pattern} を検索する
searchdecl({name} [, {global} [, {thisblock}]])
                                数値    変数の宣言を検索
searchpair({start}{middle}{end} [, {flags} [, {skip} [...]]])
                                数値    開始/終端のペアの他方を検索
searchpairpos({start}{middle}{end} [, {flags} [, {skip} [...]]])
                                リスト  開始/終端のペアの他方を検索
searchpos({pattern} [, {flags} [, {stopline} [, {timeout}]]])
                                リスト  {pattern}を検索
server2client({clientid}{string})
                                数値    返信文字列を送信する
serverlist()                    文字列  利用可能なサーバーのリストを取得
setbufvar({expr}{varname}{val})     バッファ{expr}内の変数{varname}{val}
                                        をセット
setcharsearch({dict})           辞書    文字検索を{dict}に設定
setcmdpos({pos})                数値    コマンドライン内のカーソル位置を設定
setfperm({fname}{mode})       数値    ファイル {fname} のパーミッションを
                                        {mode} に設定
setline({lnum}{line})         数値    行{lnum}{line}(文字列)をセット
setloclist({nr}{list}[, {action}[, {what}]])
                                数値    {list}を使ってロケーションリストを変更
setmatches({list})              数値    マッチのリストを復元する
setpos({expr}{list})          なし    {expr}の位置を{list}にする
setqflist({list}[, {action}[, {what}]])
                                数値    {list}を使ってQuickFixリストを変更
setreg({n}{v}[, {opt}])       数値    レジスタの値とタイプを設定
settabvar({nr}{varname}{val}) なし  タブページ{nr}の変数{varname}{val}
                                        設定する
settabwinvar({tabnr}{winnr}{varname}{val})
                                なし    タブページ{tabnr}内のウィンドウ{winnr}
                                        の変数{varname}{val}をセット
setwinvar({nr}{varname}{val}) なし  ウィンドウ{nr}の変数{varname}{val}
                                        セット
sha256({string})                文字列  {string}のSHA256チェックサム
shellescape({string} [, {special}])
                                文字列  {string}をシェルコマンド引数として使う
                                        ためにエスケープする。
shiftwidth()                    数値    実際に使用される 'shiftwidth' の値
simplify({filename})            文字列  ファイル名を可能なかぎり簡略化する
sin({expr})                     浮動小数点数    {expr} の正弦(サイン)
sinh({expr})                    浮動小数点数    {expr}のハイパボリックサイン
sort({list} [, {func} [, {dict}]])
                                リスト  比較に{func}を使って{list}をソートする
soundfold({word})               文字列  {word}のsound-fold
spellbadword()                  文字列  カーソル位置のスペルミスした単語
spellsuggest({word} [, {max} [, {capital}]])
                                リスト  スペリング補完
split({expr} [, {pat} [, {keepempty}]])
                                リスト  {expr}{pat}で区切ってリストを作る
sqrt({expr})                    浮動小数点数    {expr} の平方根
str2float({expr})               浮動小数点数    文字列を浮動小数点数に変換する
str2nr({expr} [, {base}])       数値    文字列を数値に変換する
strchars({expr} [, {skipcc}])   数値    文字列{expr}の文字の数
strcharpart({str}{start}[, {len}])
                                文字列  {str} の {start} から長さ {len} の文字
                                        列を得る
strdisplaywidth({expr} [, {col}]) 数値  文字列{expr}の表示幅
strftime({format}[, {time}])    文字列  指定されたフォーマットでの時刻
strgetchar({str}{index})      数値    {str} から {index} 番目の文字インデッ
                                        クスを得る
stridx({haystack}{needle}[, {start}])
                                数値    {haystack}内の{needle}のインデックス
string({expr})                  文字列  {expr}の値の文字列表現
strlen({expr})                  数値    文字列{expr}の長さ
strpart({src}{start}[, {len}])
                                文字列  {src}{start}から長さ{len}の部分
strridx({haystack}{needle} [, {start}])
                                数値    {haystack}内の最後の{needle}のインデッ
                                        クス
strtrans({expr})                文字列  文字列を表示可能に変更
strwidth({expr})                数値    文字列{expr}の表示セル幅
submatch({nr}[, {list}])        文字列/リスト
                                        ":s" やsubstitute()における特定のマッチ
substitute({expr}{pat}{sub}{flags})
                                文字列  {expr}{pat}{sub}に置換え
synID({line}{col}{trans})   数値    {line}{col}のsyntax IDを取得
synIDattr({synID}{what} [, {mode}])
                                文字列  syntax ID{synID}の属性{what}を取得
synIDtrans({synID})             数値    {synID}の翻訳されたsyntax ID
synconcealed({lnum}{col})     リスト  Conceal の情報
synstack({lnum}{col}) リスト  {lnum}{col}列目における構文IDの
                                        スタック
system({expr} [, {input}])      文字列  シェルコマンド{expr}の出力結果
systemlist({expr} [, {input}])  リスト  シェルコマンド{expr}の出力結果
tabpagebuflist([{arg}])         リスト  タブページ内のバッファ番号のリスト
tabpagenr([{arg}])              数値    現在または最後のタブページの番号
tabpagewinnr({tabarg}[, {arg}])
                                数値    タブページ内の現在のウィンドウの番号
taglist({expr})                 リスト  {expr}にマッチするタグのリスト
tagfiles()                      リスト  使用しているタグファイルのリスト
tan({expr})                     浮動小数点数    {expr}のタンジェント
tanh({expr})                    浮動小数点数    {expr}のハイパボリックタンジェ
                                                ント
tempname()                      文字列  テンポラリファイルの名前
test_alloc_fail({id}{countdown}{repeat})
                                なし    メモリの確保を失敗にさせる
test_autochdir()                なし    起動時に 'autochdir' を有効にする
test_garbagecollect_now()       なし    テスト用に直ちにメモリを解放する
test_ignore_error({expr})       なし    特定のエラーを無視する
test_null_channel()             チャンネル      テスト用のnull値
test_null_dict()                辞書    テスト用のnull値
test_null_job()                 ジョブ  テスト用のnull値
test_null_list()                リスト  テスト用のnull値
test_null_partial()             Funcref テスト用のnull値
test_null_string()              文字列  テスト用のnull値
test_override({expr}{val})    なし    Vimの内部処理を置き換えてテストする
test_settime({expr})            なし    テスト用に現在の時刻を設定する
timer_info([{id}])              リスト  タイマーに関する情報
timer_pause({id}{pause})      なし    タイマーの一時停止または一時停止解除
timer_start({time}{callback} [, {options}])
                                数値    タイマーを作成する
timer_stop({timer})             なし    タイマーを停止する
timer_stopall()                 なし    すべてのタイマーを停止する
tolower({expr})                 文字列  文字列{expr}を小文字にする
toupper({expr})                 文字列  文字列{expr}を大文字にする
tr({src}{fromstr}{tostr})   文字列  {src}中に現れる文字{fromstr}{tostr}
                                        に変換する
trunc({expr})                   浮動小数点数    浮動小数点数{expr}を切り詰める
type({name})                    数値    変数{name}の型
undofile({name})                文字列  {name}に対するアンドゥファイルの名前
undotree()                      リスト  アンドゥファイルツリー
uniq({list} [, {func} [, {dict}]])
                                リスト  リストから隣接した重複を削除
values({dict})                  リスト  {dict}の値のリスト
virtcol({expr})                 数値    カーソルのスクリーンカラム位置
visualmode([expr])              文字列  最後に使われたビジュアルモード
wildmenumode()                  数値    'wildmenu' モードが有効かどうか
win_findbuf({bufnr})            リスト  {bufnr}を含むウィンドウを見つける
win_getid([{win} [, {tab}]])    数値    {tab}{win}のウィンドウIDを取得
win_gotoid({expr})              数値    ID {expr}のウィンドウに行く
win_id2tabwin({expr})           リスト  ウィンドウIDからタブとウィンドウnr取得
win_id2win({expr})              数値    ウィンドウIDからウィンドウnr取得
winbufnr({nr})                  数値    ウィンドウ{nr}のバッファ番号
wincol()                        数値    カーソル位置のウィンドウ桁
winheight({nr})                 数値    ウィンドウ{nr}の高さ
winline()                       数値    カーソル位置のウィンドウ行
winnr([{expr}])                 数値    現在のウィンドウの番号
winrestcmd()                    文字列  ウィンドウサイズを復元するコマンド
winrestview({dict})             なし    現在のウィンドウのビューを復元
winsaveview()                   辞書    現在のウィンドウのビューを保存
winwidth({nr})                  数値    ウィンドウ{nr}の幅を取得
wordcount()                     辞書    バイト/文字/単語の統計情報を取得
writefile({list}{fname} [, {flags}])
                                数値    行のリストをファイル{fname}に書き込む
xor({expr}{expr})             数値    ビット排他的論理和


abs({expr})                                                     abs()
                {expr} の絶対値を返す。{expr} の値が浮動小数点数である場合は浮
                動小数点数を返す。{expr} がNumberに変換可能な場合は数値が戻
                り値になる。それ以外の場合はエラーメッセージを表示し、-1
                を返す。
                例:
                        echo abs(1.456)
                        1.456 
                        echo abs(-5.456)
                        5.456 
                        echo abs(-4)
                        4
                {+float 機能を有効にしてコンパイルしたときのみ有効}


acos({expr})                                                    acos()
                {expr} の逆余弦 (アークコサイン) をラジアンで返す。
                値は [0, pi] の範囲の浮動小数点数 (Float)。
                {expr} は [-1, 1] の範囲の浮動小数点数 (Float) か数値
                (Number) でなければならない。
                例:
                        :echo acos(0)
                        1.570796
                        :echo acos(-0.5)
                        2.094395
                {+float 機能を有効にしてコンパイルしたときのみ有効}


add({list}{expr})                                     add()
                リストList{list}の末尾に要素{expr}を追加する。結果のリストを
                返す。例:
                        :let alist = add([1, 2, 3], item)
                        :call add(mylist, "woodstock")
                Note {expr}がリストのときは、1個の要素として追加される。リスト
                を連結するにはextend()を使う。
                他の位置に要素を追加するにはinsert()を使う。


and({expr}{expr})                                     and()
                二つの引数のビット論理積。引数は数値に変換される。リスト、辞
                書、浮動小数点数を指定するとエラーになる。
                例:
                        :let flag = and(bits, 0x80)


append({lnum}{expr})                                  append()
                {expr}がリストListのときは、各要素をカレントバッファの{lnum}
                行目以降にテキストとして追加する。
                リストでないときは、{expr}をテキストとしてカレントバッファの
                {lnum}行目以降にテキストとして追加する。
                {lnum}は0でもよく、その場合は1行目の前に行を挿入する。
                失敗した場合は1を返す({lnum}が不正な範囲であるか、メモリ不足)。
                成功なら0を返す。例:
                        :let failed = append(line('$'), "# THE END")
                        :let failed = append(0, ["Chapter 1", "the beginning"])

                                                        argc()
argc()          カレントウィンドウの引数リスト内の、ファイルの数を返す。
                arglistを参照。

                                                        argidx()
argidx()        引数リスト内の現在のインデックスを返す。最初のファイルは0とな
                る。argc() - 1が最後のファイルとなる。arglistを参照。

                                                        arglistid()
arglistid([{winnr} [, {tabnr}]])
                引数リストの ID を返す。値は引数リストを区別するための数値であ
                る。ゼロはグローバル引数リストを意味する。 arglist 参照。
                引数が無効な場合は -1 を返す。

                引数を指定しなかった場合はカレントウィンドウが使われる。
                {winnr} を指定した場合はカレントタブページ内のウィンドウが使わ
                れる。
                {winnr} と {tabnr} を指定した場合は指定したタブページ内のウィ
                ンドウが使われる。
                {winnr} にはウィンドウ番号またはwindow-IDが使える。

                                                        argv()
argv([{nr}])    結果は引数リスト内の、{nr}番目のファイル。arglistを参照。
                "argv(0)" は一番最初のファイルを示す。例:
        :let i = 0
        :while i < argc()
        :  let f = escape(fnameescape(argv(i)), '.')
        :  exe 'amenu Arg.' . f . ' :e ' . f . '<CR>'
        :  let i = i + 1
        :endwhile
                引数{nr}が指定されなかった場合は、引数リストarglist全体を返
                す。

                                                        assert_equal()
assert_equal({expected}{actual} [, {msg}])
                {expected}{actual}が等しくない場合、v:errorsにエラーメッセ
                ージを追加する。
                暗黙的な変換は行われないため、文字列 "4" は数値 4 とは異なる。
                同様に、数値 4 は浮動小数点数 4.0 と異なる。ここでは
                'ignorecase' の値は使われず、大文字小文字は常に区別される。
                {msg}が省略された場合、"Expected {expected} but got {actual}"
                という形式のメッセージが生成される。
                例:
        assert_equal('foo', 'bar')
                以下の結果がv:errorsに追加される:
        test.vim line 12: Expected 'foo' but got 'bar'

assert_exception({error} [, {msg}])                     assert_exception()
                v:exception に{error}が含まれていない時、v:errorsにエラーメッ
                セージを追加する。
                これは例外を投げるコマンドのテストを行う場合に使うことができ
                る。コロンが続くエラー番号を使えば、翻訳の問題を回避できる:
                        try
                          失敗するコマンド
                          call assert_false(1, 'command should have failed')
                        catch
                          call assert_exception('E492:')
                        endtry

assert_fails({cmd} [, {error}])                                 assert_fails()
                {cmd}を実行しエラーを生成しなかった場合、v:errorsにエラーメッ
                セージを追加する。
                {error}が渡された場合、v:errmsgの一部にマッチしなければなら
                ない。

assert_false({actual} [, {msg}])                                assert_false()
                assert_equal()と同様に、{actual}がfalseでない場合、v:errors
                にエラーメッセージを追加する。
                ゼロである時、その値はfalseである。{actual}が数値でない場合、
                テストが失敗する。
                {msg}が省略された場合、"Expected False but got {actual}" とい
                う形式のメッセージが生成される。

assert_inrange({lower}{upper}{actual} [, {msg}])     assert_inrange()
                これは数値の値かをテストする。{actual}{lower}より低いか
                {upper}より大きい場合、v:errorsにエラーメッセージが追加され
                る。
                {msg}を省略すると、"Expected range {lower} - {upper}, but
                got {actual}" という形式のエラーが生成される。

                                                                assert_match()
assert_match({pattern}{actual} [, {msg}])
                {pattern}{actual}と一致しない場合、v:errorsにエラーメッセー
                ジが追加される。

                =~と同じように{pattern}が使われる: マッチングは 'magic' や
                'cpoptions' の実際の値に関係なく、'magic' が設定され、
                'cpoptions' が空であるように常に行われる。

                {actual}は文字列として使用され、自動変換が適用される。テキスト
                の先頭と最後に一致させるためには、"^" と "$" を使用すること。
                両方を使用してテキスト全体を一致させる。{訳注: 使わなければ、
                部分一致で判定が行われる。}

                {msg}を省略すると、"Pattern {pattern} does not match {actual}"
                という形式のエラーが生成される。例:
        assert_match('^f.*o$', 'foobar')
                これは v:errors に文字列が追加されることになる:
        test.vim line 12: Pattern '^f.*o$' does not match 'foobar'

                                                        assert_notequal()
assert_notequal({expected}{actual} [, {msg}])
                assert_equal() の反対: {expected}{actual}が等しいときにエ
                ラーメッセージを v:errors に追加する。

                                                        assert_notmatch()
assert_notmatch({pattern}{actual} [, {msg}])
                assert_match() の反対: {pattern}{actual}にマッチするときに
                v:errors にエラーメッセージを追加する。

assert_true({actual} [, {msg}])                                 assert_true()
                assert_equal()と同様に、{actual}がtrueでない場合、v:errors
                にエラーメッセージを追加する。
                非ゼロである時、その値はTRUEである。{actual}が数値でない場合、
                テストが失敗する。
                {msg}が省略された場合、"Expected True but got {actual}" とい
                う形式のメッセージが生成される。

asin({expr})                                            asin()
                {expr} の逆正弦 (アークサイン) をラジアンで返す。
                値は [-pi/2, pi/2] の範囲の浮動小数点数 (Float)。
                {expr} は [-1, 1] の範囲の浮動小数点数 (Float) か数値
                (Number) でなければならない。
                例:
                        :echo asin(0.8)
                        0.927295
                        :echo asin(-0.5)
                        -0.523599
                {+float 機能つきでコンパイルされたときのみ有効}


atan({expr})                                            atan()
                {expr} の逆正接(アークタンジェント)の主値を浮動小数点数
                Float で返す。主値はラジアンで[-pi/2, +pi/2]の範囲内にある。
                {expr} は Float か Number に評価されなければならない。
                例:
                        :echo atan(100)
                        1.560797
                        :echo atan(-4.01)
                        -1.326405
                {+float 機能つきでコンパイルされたときのみ有効}


atan2({expr1}{expr2})                                 atan2()
                {expr1} / {expr2} の逆正接 (アークタンジェント) をラジアンで返
                す。値は [-pi, pi] の範囲の浮動小数点数 (Float)。
                {expr1} と {expr2} は浮動小数点数 (Float) か数値 (Number)
                でなければならない。
                例:
                        :echo atan2(-1, 1)
                        -0.785398
                        :echo atan2(1, -1)
                        2.356194
                {+float 機能を有効にしてコンパイルしたときのみ有効}

balloon_show({msg})                                     balloon_show()
                {msg} をバルーン内に表示する。
                例:
                        func GetBalloonContent()
                           " 内容の取得を開始
                           return ''
                        endfunc
                        set balloonexpr=GetBalloonContent()

                        func BalloonCallback(result)
                          call balloon_show(a:result)
                        endfunc

                想定される使用方法は、バルーンの内容の取得が 'balloonexpr' か
                ら開始されることである。そこから非同期メソッドを呼び出し、コー
                ルバックから balloon_show() を呼び出す。'balloonexpr' 自身は
                空文字列かプレースホルダーを返すことができる。

                バルーンを表示できないときは何も起こらず、エラーメッセージも表
                示されない。
                {Vimが +balloon_eval 機能付きでコンパイルされたときのみ有効}

                                                        browse()
browse({save}{title}{initdir}{default})
                ファイル選択ダイアログを起動。"has("browse")" がTRUEを返すと
                き (幾つかのGUIバージョンに限定)だけ利用可能。
                入力フィールドの意味は:
                    {save}      TRUEならば書込み用ファイルの選択
                    {title}     ダイアログのタイトル
                    {initdir}   ダイアログの始まるディレクトリ
                    {default}   ファイル名の省略値
                ダイアログがキャンセルされるか、何かエラーがあるか、もしくはブ
                ラウジングが不可能ならば、空文字列が戻ってくる。

                                                        browsedir()
browsedir({title}{initdir})
                ディレクトリ選択ダイアログを起動。"has("browse")" がTRUEを返
                すとき(幾つかのGUIバージョンに限定)だけ利用可能。
                ディレクトリ選択ダイアログがないシステムにおいてはファイル選択
                ダイアログが使われる。その場合は、指定したいディレクトリの中の
                ファイルを選択すること。
                入力フィールドの意味は:
                    {title}     ダイアログのタイトル
                    {initdir}   ダイアログの始まるディレクトリ
                ダイアログがキャンセルされるか、何かエラーがあるか、もしくはブ
                ラウジングが不可能ならば、空文字列が戻ってくる。

                                                        bufexists()
bufexists({expr})
                結果は数値で、{expr}と呼ばれるバッファが存在すればTRUEとな
                る。
                {expr}が数値の場合、バッファ番号とみなされる。
                {expr}が文字列の場合、バッファ名に正確にマッチしなければな
                らない。名前として以下のものが許される:
                - カレントディレクトリからの相対パス。
                - フルパス。
                - 'buftype' が "nofile" であるバッファの名前
                - URL名。
                バッファリストにないバッファも検索される。
                Note :buffersの出力で、ヘルプファイルは短い名前でリストされ
                ているが、bufexists()は長い名前でないと見つけることができない。
                ある名前を bufexists() に与えて非零になったとしても、その名前
                をコマンド :buffer に与える際には expand() を使って展開し
                なければならない場合がある。特に MS-Windows の "c:\DOCUME~1"
                という 8.3 名形式において。
                代替ファイル名が存在するかを判定するには "bufexists(0)" を使う。
                                                        buffer_exists()
                以前の名前: buffer_exists().

buflisted({expr})                                       buflisted()
                戻り値は数値で、{expr}と呼ばれるバッファが存在しリストされてい
                る ('buflisted' オプションがオンになっている) ならば結果は
                TRUEとなる。引数{expr}bufexists()と同じように扱われる。

                                                        bufloaded()
bufloaded({expr})
                戻り値は数値で、{expr}と呼ばれるバッファが存在しロード済み(
                ウィンドウに表示されているか、隠されているかは問わない)ならば
                結果はTRUEとなる。引数{expr}bufexists()と同じように扱わ
                れる。

                                                        bufname()
bufname({expr})
                戻り値はバッファの名前。バッファ名はコマンド ":ls" で表示され
                るものと同様。
                {expr}が数値ならば、その番号のバッファ名が返される。0は現在の
                ウィンドウの代替バッファを意味する。{expr}が文字列ならば、バッ
                ファ名に対してファイル名マッチング file-pattern を行うパター
                ンとなる。このマッチングは常に、'magic' をセットし 'cpoptions'
                を空にした状態で行われる。複数マッチしてしまった場合には空文字
                列が返される。
                "" や "%" は現在のバッファを意味し、"#" は代替バッファを意味す
                る。
                完全マッチのものが優先され、完全マッチがなければ、バッファ名の
                先頭でのマッチ、末尾でのマッチ、中間でのマッチが探される。完全
                マッチのみを探すには、パターン先頭に "^" を、末尾に "$" をつけ
                る。
                まずバッファリストにあるバッファが探される。そこで1個だけマッ
                チが見つかればそれを返す。次にバッファリストにないものが探され
                る。
                {expr}が文字列のときに、それをバッファ番号として使いたいなら
                ば、0を足すことによって強制的に数値にすることができる:
                        echo bufname("3" + 0)
                バッファが存在しないか名前を持っていない場合には、空文字列が返
                される。
  bufname("#")                  alternate buffer name
  bufname(3)                    name of buffer 3
  bufname("%")                  name of current buffer
  bufname("file2")              name of buffer where "file2" matches.
                                                        buffer_name()
                以前の名前: buffer_name().

                                                        bufnr()
bufnr({expr} [, {create}])
                結果はバッファの番号。バッファ番号はコマンド ":ls" で表示され
                るものと同様。{expr}の使い方は前述のbufname()を参照。バッファ
                が存在しない場合-1が返される。ただし、{create}が与えられて0で
                ないときは、バッファリストに載せない新しいバッファを作成しその
                番号を返す。
                bufnr("$")は最後のバッファを意味する:
        :let last_buffer = bufnr("$")
                結果は存在しているバッファのうちで、もっとも大きなバッファ番号
                となる。 Note そのバッファ番号より小さいバッファ番号を持つ(ハ
                ズの)バッファが、必ずしも全て存在するとは限らない。なぜなら
                ":bwipeout" がバッファを消すことができるからだ。バッファが存在
                するかテストするにはbufexists()を使う。
                                                        buffer_number()
                以前の名前: buffer_number().
                                                        last_buffer_nr()
                bufnr("$")の以前の名前: last_buffer_nr().

bufwinid({expr})                                        bufwinid()
                その結果は数値で、バッファ{expr}に関連付けられた最初のウィンド
                ウのwindow-ID。 {expr}の使い方は前述のbufname()を参照。バッ
                ファ{expr}が存在しないか、ウィンドウが無い場合は、-1が返され
                る。例:

        echo "A window containing buffer 1 is " . (bufwinid(1))

                現在のタブページのみを処理する。

                                                        bufwinnr()
bufwinnr({expr})
                結果は数値で、バッファ{expr}に関連付けられた最初のウィンドウの
                番号。{expr}の使い方は前述のbufname()を参照。バッファ{expr}
                が存在しないか、ウィンドウが無い場合には-1を返す。例:

        echo "A window containing buffer 1 is " . (bufwinnr(1))

                この番号はCTRL-W_wや ":wincmd w" :wincmdで使える。
                カレントタブページ内のウィンドウだけを探す。

                                                        byte2line()
byte2line({byte})
                カレントバッファの先頭から{byte}番目の文字が、何行目に含まれる
                かを返す。これにはカレントバッファの 'fileformat' に依存した、
                改行文字も含まれる。先頭の文字にはバイトカウント1が与えられる。
                line2byte()go:gotoも参照。
                {+byte_offset 機能付きでコンパイルされたときのみ有効}

byteidx({expr}{nr})                                   byteidx()
                文字列{expr}{nr}番目の文字のバイトインデックスを返す。
                最初の文字の{nr}は0であり、戻り値は0となる。この関数はマルチバ
                イト文字が存在するときのみ有用であり、そうでなければこの関数が
                返す値は{nr}に等しい。
                合成文字はまとめて計算される。合成文字のバイト数はそれが合成さ
                れているベース文字のバイト数に合算される。合成文字を別々に数え
                るには byteidxcomp() を参照。
                例 :
                        echo matchstr(str, ".", byteidx(str, 3))
                は4文字目を表示する。次も同じことをする:
                        let s = strpart(str, byteidx(str, 3))
                        echo strpart(s, 0, byteidx(s, 1))
                strgetchar() と strcharpart() も参照。
                {expr}{nr}文字以下の場合は-1を返す。
                {expr}がちょうど{nr}文字の場合は文字列の長さ(バイト単位)を返す。

byteidxcomp({expr}{nr})                                       byteidxcomp()
                byteidx() と同じだが、合成文字は個別にカウントされる。例:
                        let s = 'e' . nr2char(0x301)
                        echo byteidx(s, 1)
                        echo byteidxcomp(s, 1)
                        echo byteidxcomp(s, 2)
                1 番目と 3 番目は 3 が出力される ('e' の長さと合成文字の長さを
                足すと 3 バイト)。2 番目は 1 が出力される ('e' は 1 バイト)。
                'encoding' に Unicode が設定されているときのみ byteidx() と違う
                動作になる。

call({func}{arglist} [, {dict}])                      call() E699
                リストList{arglist}の要素を引数として関数{func}を呼ぶ。
                {func}Funcrefでも関数の名前でもよい。
                a:firstlineとa:lastlineにはカレント行が代入される。
                呼び出した関数の戻り値を返す。
                {dict}は "dict" 属性つきの関数用で、これがローカル変数 "self"
                に代入される。Dictionary-functionを参照。

ceil({expr})                                                    ceil()
                {expr} 以上となる最小の整数を浮動小数点数 Float で返す
                (切り上げる)。
                {expr} は Float か Number に評価されなければならない。
                例:
                        echo ceil(1.456)
                        2.0 
                        echo ceil(-5.456)
                        -5.0 
                        echo ceil(4.0)
                        4.0
                {+float 機能つきでコンパイルされたときのみ有効}

ch_canread({handle})                                            ch_canread()
                {handle} から何か読むものがあれば非ゼロを返す。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。

                これはチャンネルから、都合のよいときに読むのに便利である。例え
                ば、タイマーから。

                チャンネルがコールバックを持っていない場合、メッセージはドロッ
                プされることに注意。それを防ぐには close コールバックを追加す
                ること。

                {+channel 機能付きでコンパイルされたときのみ有効}

ch_close({handle})                                              ch_close()
                {handle} を閉じる。channel-close を参照。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。
                閉じられたコールバックは呼び出されない。

                {+channel 機能付きでコンパイルされたときのみ有効}

ch_close_in({handle})                                           ch_close_in()
                {handle} の "入力" を閉じる。channel-close-in を参照。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。
                閉じられたコールバックは呼び出されない。

                {+channel 機能付きでコンパイルされたときのみ有効}

ch_evalexpr({handle}{expr} [, {options}])                     ch_evalexpr()
                {handle} へ {expr} を送信する。{expr} はチャンネル側と同じ型に
                エンコードされる。この関数は生のチャンネルでは使用できない。
                channel-use を参照。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。
                                                                E917
                {options} は辞書でなければならない。また "callback" のエントリ
                を持ってはならない。また個別のリクエストに対して "timeout" を
                持つ事ができる。

                ch_evalexpr() は応答を待ち、式をデコードした物が返される。エ
                ラーもしくはタイムアウトの場合は空文字列が返る。

                {+channel 機能付きでコンパイルされたときのみ有効}

ch_evalraw({handle}{string} [, {options}])            ch_evalraw()
                {handle} へ {expr} を送信する。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。

                ch_evalexpr() と同様に動作する。しかしリクエストをエンコード
                したり応答をデコードしたりはしない。呼び出しは正しいコンテンツ
                である事が保証される。また NL モードでは改行が行われるが、ここ
                では改行が付与されない。NL は応答から削除される。
                channel-use を参照。

                {+channel 機能付きでコンパイルされたときのみ有効}

ch_getbufnr({handle}{what})                            ch_getbufnr()
                {what} に使用されている {handle} のバッファ番号を得る。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。
                {what} は標準エラーの為の "err"、標準出力の為の "out"、もしく
                はソケット出力の為の空文字列が指定できる。
                バッファが存在しない場合は -1 が返る。
                {+channel 機能付きでコンパイルされたときのみ有効}

ch_getjob({channel})                                            ch_getjob()
                {channel} に関連付けられた Job を得る。
                もしジョブが無い場合、戻り値の Job で job_status() を呼び出
                すと "fail" が返される。

                {+channel と +job 機能付きでコンパイルされたときのみ有効}

ch_info({handle})                                               ch_info()
                {handle} に関する情報を辞書で返す。アイテムは:
                   "id"           チャネル番号
                   "status"       ch_status() と同様に、"open", "buffered" ま
                                  たは "closed"
                ch_open() で開いた場合:
                   "hostname"     アドレスのホスト名
                   "port"         アドレスのポート
                   "sock_status"  "open" または "closed"
                   "sock_mode"    "NL", "RAW", "JSON" または "JS"
                   "sock_io"      "socket"
                   "sock_timeout" タイムアウト(ミリ秒)
                job_start() で開いた場合:
                   "out_status"   "open", "buffered" または "closed"
                   "out_mode"     "NL", "RAW", "JSON" または "JS"
                   "out_io"       "null", "pipe", "file" または "buffer"
                   "out_timeout"  タイムアウト(ミリ秒)
                   "err_status"   "open", "buffered" または "closed"
                   "err_mode"     "NL", "RAW", "JSON" または "JS"
                   "err_io"       "out", "null", "pipe", "file" または "buffer"
                   "err_timeout"  タイムアウト(ミリ秒)
                   "in_status"    "open" または "closed"
                   "in_mode"      "NL", "RAW", "JSON" または "JS"
                   "in_io"        "null", "pipe", "file" または "buffer"
                   "in_timeout"   タイムアウト(ミリ秒)

ch_log({msg} [, {handle}])                                      ch_log()
                ch_logfile() によってログファイルが開かれている場合はチャン
                ネルのログファイルに {msg} を書き込む。
                {handle} が渡されている場合はチャンネル番号がメッセージの中で
                使われる。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。使用されるチャンネル番号のチャンネルは開いていなければな
                らない。

ch_logfile({fname} [, {mode}])                                  ch_logfile()
                {fname} へチャンネルの挙動ログ出力を開始する。
                {fname} が空の場合、ロギングは停止する。

                {mode} が省略されるか "a" の場合、ファイルへの追加になる。
                {mode} が "w" の場合、空のファイルへで開始される。

                UNIX で "tail -f" にてリアルタイムで何が行われているかが見える
                様に、ファイルはメッセージ毎にフラッシュされる。


ch_open({address} [, {options}])                                ch_open()
                {address}へのチャンネルを開く。channelを参照。
                チャンネルを返す。失敗をチェックするには ch_status() を使用
                する。

                {address} は "localhost:8765" のように "ホスト名:ポート" の形
                式である。

                {options} が与えられる場合は辞書でなければならない。
                channel-open-options を参照。

                {+channel 機能付きでコンパイルされたときのみ有効}

ch_read({handle} [, {options}])                                 ch_read()
                {handle} から読み込みメッセージを受信する。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。
                channel-more を参照。
                {+channel 機能付きでコンパイルされたときのみ有効}

ch_readraw({handle} [, {options}])                      ch_readraw()
                ch_read() と同様に動作するが JS や JSON の場合でもメッセージは
                デコードされない。channel-more を参照。
                {+channel 機能付きでコンパイルされたときのみ有効}

ch_sendexpr({handle}{expr} [, {options}])                     ch_sendexpr()
                {handle} へ {expr} を送信する。{expr} はチャンネル側と同じ型に
                エンコードされる。この関数は生のチャンネルでは使用できない。
                channel-use を参照。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。チャンネルは開いていなければならない。。

                {+channel 機能付きでコンパイルされたときのみ有効}

ch_sendraw({handle}{string} [, {options}])            ch_sendraw()
                {handle} を {string} に送る。
                ch_sendexpr() と同様に動作するが、リクエストをエンコードした
                り応答をデコードしたりはしない。呼び出しは正しいコンテンツで
                ある事が保証される。また NL モードでは改行が行われるが、ここ
                では改行が付与されない。NL は応答から削除される。
                channel-use を参照。

                {+channel 機能付きでコンパイルされたときのみ有効}

ch_setoptions({handle}{options})                      ch_setoptions()
                {handle} にオプションを設定する:
                        "callback"      チャンネルのコールバック
                        "timeout"       デフォルトの読み込みタイムアウト(ミリ秒)
                        "mode"          チャンネル全体のモード
                より詳しい説明は ch_open() を参照。
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。

                Note: モードの変更はキューイングされているメッセージを失ってし
                まうかもしれない。

                以下のオプションは変更できない:
                        "waittime"      ch_open()だけで適用できる

ch_status({handle} [, {options}])                               ch_status()
                {handle} の状態を返す:
                        "fail"          チャンネルのオープンに失敗
                        "open"          チャンネルは利用可能
                        "buffered"      チャンネルは読込可能、または書き込まれ
                                        ていない
                        "closed"        チャンネルは利用不可
                {handle} はチャンネルもしくはチャンネルを持つジョブであっても
                良い。
                チャンネルは閉じられているが ch_read() を使って残ったデータ
                をまだ読み取る事ができる場合には "buffered" が利用できる。

                {options} が指定された場合、"part" 要素でチャンネルのどのパー
                ト ("out" または "err") の状態を返すかを指定できる。例えば、エ
                ラーの状態を得るには:
                        ch_status(job, {"part": "err"})

changenr()                                              changenr()
                最も最近の変更の番号を返す。:undolistで表示される番号と同じ
                であり、:undoコマンドの引数として使うことができる。
                変更を行った直後ではその変更の番号となる。redoを行った直後は
                redoされた変更の番号となる。undoを行った直後はundoされた変更よ
                り1小さい番号になる。

char2nr({expr}[, {utf8}])                                       char2nr()
                {expr}の最初の文字のASCIIコードを返す。例:
                        char2nr(" ")            returns 32
                        char2nr("ABC")          returns 65
                {utf8} を省略、またはゼロを指定すると、現在の 'encoding' が適
                用される。"utf-8" の場合の例:
                        char2nr("á")            returns 225
                        char2nr("á"[0])         returns 195
                {utf8} に 1 を指定すると、常に utf-8 文字として扱われる。
                合成文字は個別の文字として扱われる。
                nr2char() はこの逆を行う。

cindent({lnum})                                         cindent()
                'cindent' で使われるのと同じC言語用のインデント規則に従った場
                合の{lnum}行目のインデント量を返す。
                インデント量はスペースで数えられ、'tabstop' の値は関係ない。
                {lnum}getline()の場合と同様に扱われる。
                {lnum}が無効な値のときや+cindent機能なしでコンパイルされてい
                るときは-1を返す。
                C-indentingを参照。

clearmatches()                                          clearmatches()
                matchadd() と コマンド :match により定義されたマッチをすべ
                て消去する。

                                                        col()
col({expr})     戻り値は数値で、{expr}で与えられる位置の桁番号(バイトインデッ
                クス)。有効な位置は:
                    .       現在の位置
                    $       カレント行の末尾(カレント行のバイト数+1を返す)
                    'x      マークxの位置(マークが設定されていない場合0)
                    v       ビジュアルモードでは: ビジュアル選択領域の開始行
                            (カーソルがその端)。ビジュアルモード以外ではカーソ
                            ル位置を返す。すぐに更新される点が '< と違う。
                さらに {expr} は [lnum, col] という行番号と桁番号のリストで
                あってもよい。col に "$" を指定して、ある行の最後の桁を取得す
                るのにとても便利である。"lnum" か "col" が範囲外である場合は
                0 を返す。
                行番号を取得するにはline()を使う。行番号と桁番号両方を取得す
                るにはgetpos()を使う。
                画面上の桁番号を取得するにはvirtcol()を使う。
                Note 現在のファイルのマークしか使えないことに注意。
                例:
                        col(".")                カーソルの桁
                        col("$")                カレント行の長さ+1
                        col("'t")               マークtの桁
                        col("'" . markname)     マークmarknameの桁
                先頭の桁は1になる。戻り値0はエラーを意味する。
                大文字のマークは他のバッファを指しているかもしれない。
                'virtualedit' が有効なとき、カーソルが行末を越えていると、桁番
                号は行の長さより1大きい値を返す。挿入モードで桁番号を取得する
                には次のマップが使える:
                        :imap <F2> <C-O>:let save_ve = &ve<CR>
                                \<C-O>:set ve=all<CR>
                                \<C-O>:echo col(".") . "\n" <Bar>
                                \let &ve = save_ve<CR>

complete({startcol}{matches})                 complete() E785
                挿入モード補完の候補を設定する。
                挿入モードでのみ使用できる。CTRL-R = (i_CTRL-R を参照)と組み
                合わせてマッピングを作る必要がある。CTRL-Oの後や、<expr>マッピ
                ングの中では正しく動作しない。
                {startcol}は補完すべき単語の開始位置を示す、行内のバイトオフセッ
                トである。その位置からカーソルまでのテキストが補完すべき単語と
                なる。
                {matches}はリストListでなければならない。リストの各要素が1つ
                の候補となる。この要素として許される値については
                complete-itemsを参照。
                Note この関数を呼んだ後は補完を停止させるようなテキストの挿入
                をしないように注意しなければならない。
                この関数で設定した候補は普通の挿入モード補完と同じ様にCTRL-N
                CTRL-Pで選択できる。設定されていればポップアップメニューが表示
                される。ins-completion-menuを参照。
                例:
        inoremap <F5> <C-R>=ListMonths()<CR>
        func! ListMonths()
          call complete(col('.'), ['January', 'February', 'March',
                \ 'April', 'May', 'June', 'July', 'August', 'September',
                \ 'October', 'November', 'December'])
          return ''
        endfunc
                この例はそれほど役には立たないが、使い方を示している。Note 0が
                挿入されてしまわないように空文字列を返していることに注意。

complete_add({expr})                            complete_add()
                候補のリストに{expr}を追加する。'completefunc' で指定された関
                数の中でのみ使われる。
                失敗したときは0を返す(空文字列かメモリ不足)。候補が追加された
                ときは1を返し、その候補が既にリストに存在するときは2を返す。
                {expr}の説明についてはcomplete-functionsを参照。'omnifunc'
                が返すリストと同じである。

complete_check()                                complete_check()
                補完候補を探している間にキーがタイプされたかどうか確認する。補
                完の検索に時間がかかる場合に使われる。候補の検索を中断しようと
                しているときはTRUEを返す。そうでないときは0を返す。
                'completefunc' で指定された関数の中でのみ使われる。

                                                        confirm()
confirm({msg} [, {choices} [, {default} [, {type}]]])
                confirm()はユーザーに選択させるためのダイアログを提供する。戻
                り値は選択した番号になる。最初の選択肢が1である。
                Note: confirm()は、ダイアログサポートを有効にしてコンパイルし
                た時にだけ動作する。+dialog_con+dialog_guiを参照。

                ダイアログには{msg}に加えて{choices}の選択肢が表示される。
                {choices}が指定されない、または空の場合は選択肢 "&OK" が表示さ
                れる(使用している言語に翻訳される)。
                {msg}は文字列で '\n' を改行として使用できる。幾つかのシステム
                では、長すぎる行は自動的に折り返される。

                {choices}は文字列で、個々の選択肢は '\n' によって区切られる。
                例:
                        confirm("Save changes?", "&Yes\n&No\n&Cancel")
                '&' の後の文字は選択肢のショートカットキーになる。この場合
                "Cancel" を選択するのに 'c' をタイプすることができる。ショート
                カットキーは最初の文字である必要は無い:
                        confirm("file has been modified", "&Save\nSave &All")
                コンソールでは、デフォルトのショートカットキーとして、各選択肢
                の最初の文字が使われる。

                省略可能な引数{default}<CR>キーを叩いた時に選択される選択肢
                の番号を指定する。最初の選択肢をデフォルトにするならば1を使用
                する。デフォルトを設定したくないのならば0を使用する。
                {default}を省略した場合、1が使用される。

                省略可能な引数{type}はダイアログの種類を指定する。これは GTK,
                Mac, Motif, Win32 の GUI でアイコンを指定するのに使われる。
                "Error", "Question", "Info", "Warning", "Generic" のうちどれか
                一つを指定する。以上のうちの先頭の文字だけで指定できる。{type}
                が省略された場合、"Generic" が使用される。

                ユーザーが<Esc>CTRL-Cや、その他の割りこみキーでダイアログを
                中断した場合、confirm()は0を返す。

                例:
   :let choice = confirm("What do you want?", "&Apples\n&Oranges\n&Bananas", 2)
   :if choice == 0
   :    echo "make up your mind!"
   :elseif choice == 3
   :    echo "tasteful"
   :else
   :    echo "I prefer bananas myself."
   :endif
                GUIのダイアログではボタンが使用される。ボタンの配置は
                'guioptions' の 'v' フラグに依存する。もしも 'v' フラグが含ま
                れているのなら、ボタンは常に垂直に配置される。そうでなければ水
                平に配置しようと試みられる。水平配置がうまくマッチしない場合
                は、垂直配置が使われる。幾つかのシステムでは常に水平配置が使わ
                れる。

                                                        copy()
copy({expr})    {expr}のコピーを作る。数値と文字列の場合は、{expr}そのものとコ
                ピーの間に違いはない。
                {expr}がリストListの場合は浅いコピーを作る。つまり元のリスト
                を変更してもコピーは変更されず、逆も同じである。しかし要素は共
                通で、片方の要素に対し変更を加えると、もう一方の要素も変更され
                る。
                辞書はリストと同様な方法でコピーされる。
                deepcopy()も参照。

cos({expr})                                             cos()
                {expr} の余弦(コサイン)をラジアンで浮動小数点数 Float で返す。
                {expr} は Float または Number に評価されなければならない。
                例:
                        :echo cos(100)
                        0.862319
                        :echo cos(-4.01)
                        -0.646043
                {+float 機能つきでコンパイルされたときのみ有効}


cosh({expr})                                            cosh()
                {expr} の双曲線余弦 (ハイパボリックコサイン) を返す。
                値は [1, inf] の範囲の浮動小数点数 (Float)。
                {expr} は浮動小数点数 (Float) か 数値 (Number) でなければ
                ならない。
                例:
                        :echo cosh(0.5)
                        1.127626
                        :echo cosh(-0.5)
                        -1.127626
                {+float 機能を有効にしてコンパイルしたときのみ有効}


count({comp}{expr} [, {ic} [, {start}]])                      count()
                リストListまたは辞書Dictionary {comp}の中に値{expr}が何回
                現れるかを返す。
                {start}が指定されたときはそのインデックスの要素から検索を開始
                する。{start}{comp}がリストの場合のみ使用できる。
                {ic}が指定され、TRUEの場合は大文字・小文字は区別されない。


                                                        cscope_connection()
cscope_connection([{num} , {dbpath} [, {prepend}]])
                cscope接続が存在するかどうか判定する。引数が1個も指定されな
                かった場合、戻り値は以下のようになる:
                        0, cscopeが利用できない(コンパイル時に無効化されている)
                           またはcscope接続が存在しない場合
                        1, 1個以上のcscope接続が存在する場合

                引数が与えられた場合は次のようになる。{num}は、接続の存在を確
                認する際のマッチング方法を指定する。

                {num}   存在確認の方法
                -----   ------------------------------
                0       引数なしの場合と同じ (例: "cscope_connection()")。
                1       {prepend}を無視し、{dbpath}に部分マッチを行う。
                2       {prepend}を無視し、{dbpath}に部分マッチを行う。
                3       {prepend}を使用し、{dbpath}{prepend}に部分マッチを行
                        う。
                4       {prepend}を使用し、{dbpath}{prepend}に完全マッチを行
                        う。

                Note: 以上のどの場合も文字列の比較は大文字・小文字を区別する。

                例: ":cs show" の表示が以下のようになったとする:

  # pid    database name                        prepend path
  0 27664  cscope.out                           /usr/local

                実行                                            戻り値
                ----------                                      ----------
                cscope_connection()                                     1
                cscope_connection(1, "out")                             1
                cscope_connection(2, "out")                             0
                cscope_connection(3, "out")                             0
                cscope_connection(3, "out", "local")                    1
                cscope_connection(4, "out")                             0
                cscope_connection(4, "out", "local")                    0
                cscope_connection(4, "cscope.out", "/usr/local")        1

cursor({lnum}{col} [, {off}])                         cursor()
cursor({list})
                {lnum}行目の{col}桁目(バイトで数える)にカーソルを移動させる。
                桁番号{col}は1から始まる。

                引数に {list} が 1 つだけ指定された場合は、それは要素が 2 個か
                3 個、または 4 個の List として解釈される:
                        [{lnum}{col}]
                        [{lnum}{col}{off}]
                        [{lnum}{col}{off}{curswant}]
                これは getpos() や getcurpos() の戻り値とほぼ同じである。
                違いは最初の要素がないこと。

                この関数を呼んでもジャンプリストは変更されない。
                {lnum}がバッファの行数よりも大きい場合は、最後の行へ移動する。
                {lnum}が0の場合はカレント行に留まる。
                {col}がその行のバイト数より大きい場合は、その行の最後の文字へ
                移動する。
                {col}が0の場合は、カレント桁に留まる。
                {curswant} が与えられた場合は、縦方向移動の優先的列番号として
                使われる。指定がない場合は {col} が使われる。

                'virtualedit' が有効のとき、{off}は文字の先頭からの画面上のオ
                フセットを指定する。例えば、<Tab>の中の位置や最後の文字より後
                などへも移動できる。
                カーソルを移動できたときは 0 を、できなかったときは-1 を返す。

deepcopy({expr}[, {noref}])                             deepcopy() E698
                {expr}のコピーを作る。数値と文字列の場合は、{expr}そのものとコ
                ピーの間に違いはない。
                {expr}がリストListの場合は完全なコピーを作る。つまり元のリス
                トを変更してもコピーは変更されず、逆も同じである。要素の1つが
                リストまたは辞書であるときは、再帰的にコピーが作成される。
                よってコピーの要素に変更を加えても元のリストの要素は変更を受け
                ない。
                辞書はリストと同様な方法でコピーされる。
                {noref}が省略された、または0のとき、含まれているリストや辞書は
                1度だけコピーされる。全ての参照はこのただ1つのコピーを指す。
                {noref}が1の場合、リストや辞書は現れるたびに新しいコピーが作ら
                れる。そのため循環参照があるとdeepcopy()は失敗する。
                                                                E724
                ネストは100レベルまで可能である。それ以上参照を繰り返している
                要素があると、{noref}が1の場合は失敗する。
                copy()も参照。

delete({fname} [, {flags}])                                     delete()
                {flags}を指定しないもしくは{flags}を空で指定した場合: ファイル
                {fname}を削除する。
                これは{fname}がシンボリックリンクの時でも動作する。

                {flags}が "d" の場合: ディレクトリ{fname}を削除する。
                これはディレクトリ{fname}が空でない場合は失敗する。

                {flags}が "rf" の場合: ディレクトリ{fname}、その中に含むすべて
                のものを再帰的に削除する。気をつけて!
                Note: MS-Windowsでは、使用中のディレクトリを削除することはでき
                ない。

                シンボリックリンクは、それが示すものではなく、リンク自身が削除
                される。

                結果は数値であり、削除に成功すれば 0、削除に失敗すれば -1 であ
                る。

                バッファから行を削除するには:deleteを使う。行番号が変数に入っ
                ている場合は:exeを使う。

                                                        did_filetype()
did_filetype()  autocommandが実行されFileTypeイベントが一度でも起こっていれば、
                TRUEが返る。スクリプトのFileTypeイベントが、複数回呼び出され
                るのを回避するのに使える。 FileType
                他のファイルへ移動すると、このカウンタはリセットされる。よって
                実際は、カレントバッファに対してFileTypeイベントが発生したかど
                うかを判定する。他のバッファを開くオートコマンドの中でこの関数
                を使って 'filetype' を設定し、構文ファイルを読み込むために使え
                る。

diff_filler({lnum})                                     diff_filler()
                {lnum}行目より上にある削除行の数を返す。削除行とは、差分モード
                で他方のウィンドウにテキストが挿入されていることを表す行のこと
                である。削除行は表示はされているが、実際にはバッファに存在しな
                い。
                {lnum}getline()と同様に扱われる。つまり "." はカレント行と
                なり、"'m" はマークmを表す。
                カレントウィンドウが差分モードでないときは0を返す。

diff_hlID({lnum}{col})                                diff_hlID()
                差分モードで{lnum}{col}桁(バイト単位)の位置のハイライトIDを
                返す。カレント行に変更がないときは0を返す。
                {lnum}getline()と同様に扱われる。つまり "." はカレント行と
                なり、"'m" はマークmを表す。
                先頭の桁の{col}は1となり、最初の行の{lnum}は1となる。
                ハイライトIDはsynIDattr()を使って構文情報を得るために使える。

empty({expr})                                           empty()
                {expr}が空なら1を、そうでなければ0を返す。
                - リストListまたは辞書Dictionaryは要素を1個も持たないとき
                  空とみなされる。
                - 数値と浮動小数点数は値が0のとき空とみなされる。
                - v:falsev:nonev:null は空であり、v:true は空では
                  ない。
                - ジョブは開始に失敗したときは空である。
                - チャンネルは閉じられていると空である。
                長いリストに対しては長さを0と比較するよりこちらの方がずっと高
                速である。

escape({string}{chars})                               escape()
                {string}内に現れる{chars}の文字をバックスラッシュでエスケープ
                する。例:
                        :echo escape('c:\program files\vim', ' \')
                結果:
                        c:\\program\ files\\vim
                shellescape() も参照。

                                                        eval()
eval({string})  {string}を評価し、値を返す。string()の戻り値を元の値に戻すの
                に非常に便利である。数値、浮動小数点数文字列、それらの複合に対
                して動作する。実際に存在する関数へのFuncrefに対しても動作す
                る。

eventhandler()                                          eventhandler()
                イベントハンドラの中では1を返す。つまり、ユーザーの文字入力を
                待っている間に、ファイルをドラッグ&ドロップするなど割り込みさ
                れたことを表す。このときは対話的なコマンドは使えない。イベント
                ハンドラの中でないときは0を返す。

executable({expr})                                      executable()
                {expr}という名前の実行可能ファイルが存在するかどうか判定する。
                {expr}は引数を何もつけないプログラム名でなければならない。
                executable()は$PATHと通常のプログラム検索ディレクトリを参照す
                る。                                    PATHEXT
                MS-DOSとMS-Windowsでは ".exe"、".bat" などの拡張子は含めても含
                めなくてもよい。省略された場合は$PATHEXTの拡張子を検索する。
                よって "foo.exe" が存在しなければ "foo.exe.bat" が見つかること
                もありうる。$PATHEXTが存在しなければ ".exe;.com;.bat;.cmd" が
                使われる。$PATHEXTにドットだけを含めると拡張子なしの名前を検索
                することができる。'shell' がUnixシェルのように思われるときは、
                {expr}の後に拡張子をつけない名前も検索される。
                MS-DOSとMS-Windowsではファイルが存在するかどうかだけを判定し、
                それがディレクトリでないことや、それが本当に実行可能であるかど
                うかは判定されない。
                MS-WindowsではVimと同じディレクトリにある実行ファイルは必ず発
                見できる。Vimがこのディレクトリを$PATHに加えるためである。
                win32-PATH
                戻り値は数値:
                        1       存在する
                        0       存在しない
                        -1      このシステム上では実装されていない

execute({command} [, {silent}])                                 execute()
                単一あるいは複数のExコマンドを実行して、出力を文字列として返
                す。
                {command} は文字列かリストを使える。リストの場合はそれらの行は
                一行ずつ実行される。
                以下と同等である:
                        redir => var
                        {command}
                        redir END

                オプションの {silent} の引数は以下の値を取ることができる:
                        ""              :silent を使わない
                        "silent"        :silent を使う
                        "silent!"       :silent!を使う
                デフォルトは "silent" である。 Note "silent!" は redir とは
                異なり、エラーメッセージは削除されることに注意すること。もし外
                部コマンドを使って画面がおかしくなる様であれば、代わりに
                system()を使うことができる。
                                                        E930
                {command} の中のどこかで:redirを使うことができない。

                行のリストを得るために、出力にsplit()を使うことができる:

                        split(execute('args'), "\n")

                再帰的に使用されると、再帰呼び出しの出力は、上位呼び出しの出力
                に含まれません。

exepath({expr})                                         exepath()
                {expr} が実行ファイルで、それが絶対パス、相対パス、または
                $PATH の中に存在する場合は、そのフルパスを返す。
                Note{expr} が "./" で開始している場合はカレントディレクトリ
                が使われる。Vim のパスを得る場合に問題になるかもしれない:
                        echo exepath(v:progpath)
                {expr} が $PATH の中に見つからないか、それが実行ファイルではな
                かった場合は空文字列が返る。

                                                        exists()
exists({expr})  結果は数値で、変数{expr}が存在すればTRUEとなり、そうでなけれ
                ば0となる。

                ある機能がサポートされているか判定するにはhas()を使う。
                ファイルが存在するかを判定するにはfilereadable()を使う。

                引数{expr}は文字列で次のうちいずれかである。
                        &option-name    Vimオプション(存在するかだけを判定し、
                                        本当に動作するかは判定しない)
                        +option-name    動作するVimオプション
                        $ENVNAME        環境変数(空文字列と比較することでも判
                                        定できる)
                        *funcname       組み込み関数(functions参照)かユーザー
                                        が定義した関数(user-functions参照)。
                                        また Funcref である変数に対しても動作
                                        する。
                        varname         内部変数(internal-variables)
                                        curly-braces-namesDictionaryの要
                                        素、Listの要素などに対しても動作する。
                                        インデックスの評価で無効な式であるとエ
                                        ラーメッセージが出る可能性があることに
                                        注意。例:
                                           :let l = [1, 2, 3]
                                           :echo exists("l[5]")
                                           0
                                           :echo exists("l[xx]")
                                           E121: Undefined variable: xx
                                           0
                        :cmdname        exコマンド: 組み込みコマンド、ユーザー
                                        定義コマンド、コマンド修飾子:command
                                        戻り値:
                                        1  コマンド名の先頭に一致
                                        2  コマンド名に完全一致
                                        3  複数のユーザー定義コマンドに一致
                                        コマンドが定義されているかどうかを判定
                                        するには、必ず戻り値が2であるかを確認
                                        すること。
                        :2match         :2matchのコマンド。
                        :3match         :3matchのコマンド。
                        #event          このイベントに対するオートコマンド定義
                        #event#pattern  このイベントとパターンに対するオートコ
                                        マンド定義(パターンは文字そのままに解
                                        釈され、オートコマンドのパターンと1文
                                        字ずつ比較される)
                        #group          オートコマンドグループが存在するか
                        #group#event    このグループとイベントに対してオートコ
                                        マンドが定義されているか
                        #group#event#pattern
                                        このグループ、イベント、パターンに対す
                                        るオートコマンド定義
                        ##event         このイベントに対するオートコマンドがサ
                                        ポートされているか

                例:
                        exists("&shortname")
                        exists("$HOSTNAME")
                        exists("*strftime")
                        exists("*s:MyFunc")
                        exists("bufcount")
                        exists(":Make")
                        exists("#CursorHold")
                        exists("#BufReadPre#*.gz")
                        exists("#filetypeindent")
                        exists("#filetypeindent#FileType")
                        exists("#filetypeindent#FileType#*")
                        exists("##ColorScheme")
                シンボルである&/$/*と名前の間には、空白文字があってはならな
                い。
                ある少数の場合では無視されるが、名前の後に余計な文字があっては
                ならない。将来はもっと厳格になる可能性があるので、現在許される
                からといって頼ってはならない。
                正しい例:
                        exists(":make")
                正しくない例:
                        exists(":make install")

                Note 引数は変数そのものではなく、文字列でなければならない。例
                えば、次は動作しない:
                        exists(bufcount)
                これは変数 "bufcount" の存在を判定するのではなく、bufcountの値
                を渡し、それが存在するかどうか判定してしまう。

exp({expr})                                             exp()
                {expr} の指数を返す。
                値は [0, inf] の範囲の浮動小数点数 (Float)。
                {expr} は浮動小数点数 (Float) か数値 (Number) でなければな
                らない。
                例:
                        :echo exp(2)
                        7.389056
                        :echo exp(-1)
                        0.367879
                {+float 機能を有効にしてコンパイルしたときのみ有効}


expand({expr} [, {nosuf} [, {list}]])                           expand()
                ワイルドカードと{expr}内の特殊なキーワードを展開する。
                'wildignorecase' が適用される。

                {list} が指定されその値がTRUEなら、結果はリストで返される。
                そうでない場合は結果は文字列で返される。その場合、複数のマッチ
                があるときはそれらは文字 <NL> で区切られる。[Note: バージョン
                5.0 では空白文字が用いられ、スペースを含むファイル名について問
                題を引き起こしていた]

                展開が失敗した場合、結果は空文字列となる。{expr} が '%'、'#'、
                '<' で始まらない限り、存在しないファイル名というのは、結果の文
                字列には含まれない。下記を参照のこと。

                {expr} が '%' か '#' か '<' で始まる場合には、展開は
                cmdline-specialのように、変換子を受け付け、それらに関連付け
                られた変換が施される。ここに簡単な概略を示す:

                        %               現在のファイル名
                        #               代替バッファのファイル名
                        #n              n番の代替バッファのファイル名
                        <cfile>         カーソルの下のファイル名
                        <afile>         autocmdのファイル名
                        <abuf>          autocmdのバッファ名
                        <sfile>         取り込み(source)中のファイル名、関数名
                        <slnum>         取り込み(source)中の行番号
                        <cword>         カーソル下の単語(word)
                        <cWORD>         カーソル下の単語(WORD)
                        <client>        最後に受け取ったメッセージの{clientid}
                                        server2client()
                変換子:
                        :p              フルパス名を展開
                        :h              ヘッド(ディレクトリ)
                        :t              テイル(ファイル名だけ)
                        :r              拡張子が削除される
                        :e              拡張子だけ

                例:
                        :let &tags = expand("%:p:h") . "/tags"
                '%' や '#' や '<' で始まる文字列を展開する時には、それに続くテ
                キストは無視されることに注意。従ってこれは正しくない:
                        :let doesntwork = expand("%:h.bak")
                こうすると良い:
                        :let doeswork = expand("%:h") . ".bak"
                "<cfile>" やそれらを展開する時には、戻り値が完全な展開をされな
                い参照名であることにも注意が必要。もしも "<cfile>" が
                "~/.cshrc" であった場合、"~/" を展開してホームディレクトリにす
                るために、もう一度expand()を呼び出す必要がある:
                        :echo expand(expand("<cfile>"))

                変数と変換子の間には空白文字があってはならない。関数
                fnamemodify()が通常のファイル名の変換には使用可能である。

                カレントバッファや代替バッファの名前が未定義のときに '%' や
                '#' を使うと空文字列になる。"%:p" を名無しのバッファに使用した
                場合、結果はカレントディレクトリに '/' が付加されたものになる。

                '%' や '#' や '<' で始まらない{expr}は、コマンドラインのファイ
                ル名と同じように展開される。{nosuf}引数にTRUEを指定しない限
                り、'suffixes' と 'wildignore' が使用される。
                存在しないファイルの名前も結果の文字列に含まれる。"**" を使う
                とディレクトリツリーを検索できる。例えば、カレントディレクトリ
                以下にある全ての "README" を見つけるには次のようにする:
                        :echo expand("**/README")

                expand() はシェルの持っている変数や環境変数を展開できる。しか
                し展開のためにシェルを起動するかもしれないので速度が遅くなるこ
                とがある。expr-env-expand 参照。
                展開された変数はファイル名のリストのように扱われる。環境変数を
                展開できないときはそのままになる。よって、
                ":echo expand('$FOOBAR')" の結果は "$FOOBAR" となる。

                存在するファイルを探すにはglob()を参照。外部コマンドの「生
                の」実行結果を扱うにはsystem()を参照。

extend({expr1}{expr2} [, {expr3}])                    extend()
                {expr1}{expr2}は両方ともリストListであるか、両方とも辞書
                Dictionariesでなければならない。

                両方ともリストであるなら、{expr2}{expr1}に付け加える。
                {expr3}が指定された場合は、{expr1}の第{expr3}番目の要素の前に
                {expr2}の要素を挿入する。{expr3}が0のときは最初の要素の前に挿
                入する。{expr3}がlen({expr1})に等しいときは末尾に{expr2}が付け
                加えられる。
                例:
                        :echo sort(extend(mylist, [7, 5]))
                        :call extend(mylist, [2, 3], 1)
                {expr1} が {expr2} と同じリストである場合、コピーされる要素の
                数はリストの元の長さと同じである。
                例として {expr3} が 1 のとき、最初の要素の N 個の新しいコピー
                が挿入される(ここで N はリストの元の長さ)。
                リストに1個の要素を加えるにはadd()を使う。2つのリストを連結
                して新しいリストを作るには演算子+を使う:
                        :let newlist = [1, 2, 3] + [4, 5]

                両方とも辞書である場合:
                {expr2}の全要素を{expr1}に加える。
                {expr1}{expr2}で共通のキーがある場合は、{expr3}によって動作
                が決まる:
                {expr3} = "keep" の場合: {expr1}の値そのままにする
                {expr3} = "force" の場合: {expr2}の値で上書きする
                {expr3} = "error" の場合: エラーメッセージを表示する    E737
                {expr3}が省略された場合は "force" と同じになる。

                {expr2}が空でないならば{expr1}が変更される。必要ならば最初に
                {expr1}のコピーを作ること。
                {expr2}は変更されない。
                {expr1} がロックされていて、かつ {expr2} が空でない場合は操作
                は失敗する。
                {expr1}を返す。


feedkeys({string} [, {mode}])                           feedkeys()
                {string}中の各文字を、あたかもマッピングまたはユーザーによって
                タイプされたかのように、処理キューに入れる。デフォルトではこれ
                らの文字は先行入力バッファの末尾に付け足される。そのためマッピ
                ングを展開している途中であれば、これらの文字はマッピングを展開
                した後に来ることになる。他の文字の前に挿入するには、'i' フラグ
                を使用する。それらはマッピングからの任意の文字の前の挿入の次に
                実行される。
                この関数は、{string}中の文字が処理されるまでは待たない。
                特殊なキーを{string}に含めるにはダブルクォートと "\..." 記法を
                使う(expr-quoteを参照)。例えば、feedkeys("\<CR>")は<Enter>
                キーの押下をシミュレートする。しかしfeedkeys('\<CR>')とすると、
                この文字の通り5文字を挿入する。
                {mode}が省略されたときは、挿入されたキーはマップ展開の対象にな
                る。{mode}は以下の文字フラグを含む文字列:
                'm'     キーをマップ展開する。これが既定である。
                'n'     キーをマップ展開しない。
                't'     キーをタイプされたかのように扱う。そうでない場合は
                        マッピングから展開されたかのように扱われる。これは
                        undoや折り畳みの展開などで違いが現れる。
                'i'     追加する代わりに文字を挿入する。(上記参照)
                'x'     先行入力が空になるまでコマンドを実行する。
                        これは ":normal!" を使うのと似ている。
                        'x' なしで数回feedkeys()を呼んだ後、'x' ありで1回
                        ({string}が空でも可能) feedkeys()を呼ぶことで先行入力
                        をすべて実行できる。Note Vimが挿入モードを終了したとき
                        は、スクリプト続行前の文字入力待ちによる立ち往生を避け
                        るために、<Esc>が入力されたかのように振る舞う。
                '!'     'x' と一緒に使用すると挿入モードを終了しない。タイマー
                        が少し後で挿入モードを終了するように設定されているとき
                        にテストで使用できる。CursorHoldIのテストに便利である。

                戻り値は常に0。

                                                        filereadable()
filereadable({file})
                結果は数値で、{file}というファイルが存在し、読みこむことが可能
                ならばTRUEとなる。ファイル{file}が存在しないかディレクトリ
                だった場合には、結果はFALSEとなる。引数{file}は文字列として
                使えればどのような表現でもよい。
                ファイルが読み込み可能でなくてもよい場合にはglob()を使う。
                                                        file_readable()
                以前の名前: file_readable().

filewritable({file})                                    filewritable()
                結果は数値で、{file}というファイルが存在し、書き込むことが可能
                ならば1となる。ファイル{file}が存在しないか書き込み不可能であ
                る場合には、結果は0となる。{file}がディレクトリであり、書き込
                み可能な場合、結果は2となる。


filter({expr1}{expr2})                                        filter()
                {expr1}はリストListまたは辞書Dictionaryでなければならない。
                {expr1}の各要素に対して{expr2}を評価し、その結果が0ならばリス
                トまたは辞書からその要素を削除する。
                {expr2}は文字列stringまたは関数参照Funcrefでなければならな
                い。

                {expr2}が文字列の場合、{expr2}の内部ではv:valが現在の要素の
                値を保持している。辞書の場合はv:keyが現在の要素のキーを保持
                しており、リストの場合はv:keyが現在の要素のインデックスを保
                持している。
                例:
                        call filter(mylist, 'v:val !~ "OLD"')
                は要素 "OLD" を削除する。
                        call filter(mydict, 'v:key >= 8')
                は8未満のキーを持つ要素を削除する。
                        call filter(var, 0)
                は全要素を削除する。つまりリストまたは辞書をクリアする。

                Note {expr2}は式を表す文字列である。バックスラッシュを二重に
                しなくても済むようにliteral-stringを使うとよいだろう。ただし
                その場合はシングルクォートを二重にしなければならない。

                {expr2}Funcrefの場合は、2つの引数で呼び出される:
                        1. 現在の要素のキーまたはインデックス。
                        2. 現在の要素の値。
                関数は、その要素を保持すべきときはTRUEを返さなければならな
                い。リストの奇数版目の要素を保持する例:
                        func Odd(idx, val)
                          return a:idx % 2 == 1
                        endfunc
                        call filter(mylist, function('Odd'))
                lambda を使えばより短く書ける:
                        call filter(myList, {idx, val -> idx * val <= 42})
                "val" を使わない場合は省略できる:
                        call filter(myList, {idx -> idx % 2 == 1})

                この操作はその場で(in-place)行われる。リストや辞書を変更したく
                ない場合は最初にコピーを作ること:
                        :let l = filter(copy(mylist), 'v:val =~ "KEEP"')

                {expr1}のリストまたは辞書をフィルターした結果を返す。{expr2}
                評価している最中にエラーが発生した場合は、{expr1}内のそれ以降
                の要素の処理は行われない。{expr2}が関数参照の場合、関数が
                "abort" フラグつきで定義されていない限り、関数内のエラーは無視
                される。


finddir({name}[, {path}[, {count}]])                            finddir()
                {path}から{name}という名前のディレクトリを探す。ディレクトリを
                上方・下方のどちらにも再帰的に検索できる。{path}の記法について
                はfile-searchingを参照。
                最初に見つかったディレクトリのパスを返す。そのディレクトリがカ
                レントディレクトリの下にある場合は相対パスを返す。そうでなけれ
                ば絶対パスを返す。
                {path}が省略されたとき、または空のときはオプション 'path' の値
                が使われる。
                省略可能な引数{count}が指定されたときは、最初に見つかったディ
                レクトリでなく、{count}番目に見つかったディレクトリを返す。
                {count}が負の場合は、見つかったディレクトリ全てのリストList
                を返す。これはexコマンド:findによく似ている。
                {+file_in_path 機能付きでコンパイルされたときのみ利用可能}

findfile({name}[, {path}[, {count}]])                           findfile()
                finddir()と同様だが、ディレクトリでなくファイルを検索する。
                'suffixesadd' が適用される。
                例:
                        :echo findfile("tags.vim", ".;")
                この例は、カレントファイルがあるディレクトリから上方に
                "tags.vim" を見つけるまで再帰的に検索する。

float2nr({expr})                                        float2nr()
                {expr} の小数点以下を切り捨てて Number に変換する。
                {expr} は Float または Number に評価されなければならない。
                {expr} の値が Number の範囲外の場合、結果は 0x7fffffff また
                は -0x7fffffff になる(64ビット数値が有効化されている場合は
                0x7fffffffffffffff または -0x7fffffffffffffff)。
                NaN は -0x80000000 になる(64ビット数値が有効化されている場合は
                -0x8000000000000000)。
                例:
                        echo float2nr(3.95)
                        3 
                        echo float2nr(-23.45)
                        -23 
                        echo float2nr(1.0e100)
                        2147483647  (または 9223372036854775807)
                        echo float2nr(-1.0e150)
                        -2147483647  (または -9223372036854775807)
                        echo float2nr(1.0e-100)
                        0
                {+float 機能つきでコンパイルされたときのみ有効}


floor({expr})                                                   floor()
                {expr} 以下の最大の整数を Float で返す(切り捨て)。
                {expr} は Float または Number に評価されなければならな
                い。
                例:
                        echo floor(1.856)
                        1.0 
                        echo floor(-5.456)
                        -6.0 
                        echo floor(4.0)
                        4.0
                {+float 機能つきでコンパイルされたときのみ有効}


fmod({expr1}{expr2})                                  fmod()
                {expr1} / {expr2} の余りを返す (割り算が表現できなくても)。
                {expr2} が非ゼロなら {expr1} - i * {expr2} の結果を返す (i は
                戻り値が {expr1} と同じ符号を持ちその絶対値が {expr2} よりも小
                さくなるような値)。{expr2} がゼロならゼロが返る。戻り値の型は
                浮動小数点数 (Float)。
                {expr1} と {expr2} は浮動小数点数 (Float) か数値 (Number)
                でなければならない。
                例:
                        :echo fmod(12.33, 1.22)
                        0.13
                        :echo fmod(-12.33, 1.22)
                        -0.13
                {+float 機能を有効にしてコンパイルしたときのみ有効}


fnameescape({string})                                   fnameescape()
                コマンド引数のファイル名として使うために {string} をエスケープ
                する。'%' や '|' など特別な意味を持つ全ての文字がバックスラッ
                シュでエスケープされる。
                特別な文字とは、ほとんどのシステムにおいて
                " \t\n*?[{`$\\%#'\"|!<" である。ファイル名にバックスラッシュが
                現れるシステムにおいては 'isfname' の値に依存する。
                先頭の '+' と '>' もエスケープされる(:edit と :write の引
                数では特別な意味を持つ)。{string} が "-" である場合もエスケー
                プされる(:cd の引数では意味を持つ)。
                例:
                        :let fname = '+some str%nge|name'
                        :exe "edit " . fnameescape(fname)
                上記は次と同じ結果になる:
                        edit \+some\ str\%nge\|name

fnamemodify({fname}{mods})                            fnamemodify()
                ファイル名{fname}{mods}にしたがって変更する。{mods}はコマン
                ドラインで使われるのと同様な文字列である。詳細は
                filename-modifiersを参照。
                例:
                        :echo fnamemodify("main.c", ":p:h")
                結果:
                        /home/mool/vim/vim/src/
                Note{fname}の中の環境変数は展開されない。環境変数を展開させ
                るにはexpand()を使うこと。

foldclosed({lnum})                                      foldclosed()
                結果は数値。{lnum}行目が閉じた折り畳みの中にあるなら、その折り
                畳みを構成する最初の行の行番号を返す。{lnum}行目が閉じた折り畳
                みに入っていないなら-1を返す。

foldclosedend({lnum})                                   foldclosedend()
                結果は数値。{lnum}行目が閉じた折り畳みの中にあるなら、その折り
                畳みを構成する最後の行の行番号を返す。{lnum}行目が閉じた折り畳
                みに入っていないなら-1を返す。

foldlevel({lnum})                                       foldlevel()
                カレントバッファの{lnum}行目の折り畳みレベルを表す数値を返す。
                折り畳みがネストしているときは一番下のレベルを返す。{lnum}行目
                に折り畳みがまったくないときは0を返す。折り畳みが開いているか
                閉じているかは関係ない。('foldexpr' の中で)折り畳みを更新して
                いる最中に呼ぶと、まだ折り畳みを更新していなく、折り畳みレベル
                が未知の行に対しては-1を返す。特別な場合として、普通は1行前の
                レベルは取得できる。

                                                        foldtext()
foldtext()      閉じた折り畳みに表示する文字列を返す。これはオプション
                'foldtext' のデフォルトの関数であり、'foldtext' を評価している
                ときにだけ呼ぶようにすべきである。この関数は変数v:foldstart,
                v:foldendv:folddashesを使用する。
                戻り値の文字列は次のようになる:
                        +-- 45 lines: abcdef
                
                ダッシュ(-)の数は折り畳みレベルによって決まる。"45" はその折り
                畳みに含まれている行数である。"abcdef" はその折り畳みの中の最
                初の空行でない行のテキストである。行頭の空白と、"//" や "/*"、
                'foldmarker' と 'commentstring' に設定されている文字列は削除さ
                れる。
                {+folding機能付きでコンパイルされたときのみ利用可能}

foldtextresult({lnum})                                  foldtextresult()
                {lnum}行目の閉じた折り畳みに表示される文字列を返す。'foldtext'
                を適切なコンテキストの中で評価する。{lnum}行目に閉じた折り畳み
                がないときは空文字列を返す。
                {lnum}getline()のときと同様に扱われる。つまり "." はカレン
                ト行、"'m" はマークmを表す。
                折り畳まれたテキストをHTMLなどにエクスポートするときに有用。
                {+folding機能付きでコンパイルされたときのみ利用可能}

                                                        foreground()
foreground()    Vimのウィンドウを前面に移動する。この関数はクライアントからVim
                サーバーへ送ると便利である。remote_send()
                Win32では自分自身のウィンドウを前面に持ってくることが必ずしも
                許可されていないので、動作しないかもしれない。そのときは代わり
                にremote_foreground()を使うこと。
                {Win32, Athena, Motif, GTKいずれかのGUI版とWin32コンソール版で
                のみ利用できる}

                                                funcref()
funcref({name} [, {arglist}] [, {dict}])
                function()と全く同じである。ただし、Funcrefは名前ではなく関
                数の参照で検索された関数の参照を返す。これは関数{name}が後で
                再定義されるときに重要である。

                function()とは違い、{name}はユーザー定義関数として存在してい
                なければならない。また、autoload関数についても同様である。
                {name}は組込み関数であってはならない。

                                        function() E700 E922 E923
function({name} [, {arglist}] [, {dict}])
                関数{name}を参照するFuncrefの変数を返す。{name}はユーザー定義
                関数でも組み込み関数でもよい。

                ここで{name}は関数の参照、もしくは部分適用である。部分適用であ
                るとき、それに格納されている辞書が使用され、{dict}引数が使用で
                きない。例:
                        let FuncWithArg = function(dict.Func, [arg])
                        let Broken = function(dict.Func, [arg], dict)

                Funcrefが利用されるとき、その関数は{name}から見つけられる。こ
                れは後で再定義された場合も同様である。常に同じ関数を見つけるた
                めにはfuncref()を使うこと。

                {arglist}もしくは{dict}が与えられると、関数の部分適用が作られ
                る。すなわち引数のリスト及び/または辞書はFuncrefに格納され、
                そのFuncrefが呼ばれるときに使用される。
                
                格納された引数は他の引数よりも前に関数に渡される。例えば:
                        func Callback(arg1, arg2, name)
                        ...
                        let Func = function('Callback', ['one', 'two'])
                        ...
                        call Func('name')
                関数は次のように呼び出す:
                        call Callback('one', 'two', 'name')

                function()はFuncrefにより多くの引数を加えるためにネストして呼
                び出すことができる。余分な引数は、引数のリストに追加される。
                例えば:
                        func Callback(arg1, arg2, name)
                        ...
                        let Func = function('Callback', ['one'])
                        let Func2 = function(Func, ['two'])
                        ...
                        call Func2('name')
                これは次のように関数を呼び出す:
                        call Callback('one', 'two', 'name')

                辞書は "dict" 関数を呼び出すときのみ有用である。この場合、
                {dict}は "self" として渡される。例えば:
                        function Callback() dict
                           echo "called for " . self.name
                        endfunction
                        ...
                        let context = {"name": "example"}
                        let Func = function('Callback', context)
                        ...
                        call Func()     " will echo: called for example
                余分な引数がない場合、funciton()は必要ない。以下の二つは同等で
                ある:
                        let Func = function('Callback', context)
                        let Func = context.Callback

                引数のリストと辞書を同時に使用することもできる:
                        function Callback(arg1, count) dict
                        ...
                        let context = {"name": "example"}
                        let Func = function('Callback', ['one'], context)
                        ...
                        call Func(500)
                これは次のように関数を呼び出す:
                        call context.Callback('one', 500)


garbagecollect([{atexit}])                              garbagecollect()
                循環参照を持ち、使われていないリストList、辞書
                Dictionaries、チャンネルChannels、ジョブJobs をクリーン
                アップする。

                これはメモリ不足に陥ったときや、'updatetime' 経過後ユーザーの
                キー入力を待っているときに自動的に行われるので、この関数を呼ぶ
                必要があることはほとんどない。循環参照を持たない要素は、使われ
                なくなったとき必ず解放される。長時間実行されるスクリプトの中で
                循環参照を持つ非常に大きなリストや辞書を削除したときに有用であ
                る。

                省略可能な引数 {atexit} に 1 を指定すると、Vim を終了するとき
                にもガーべッジコレクションが行われる。これはメモリリークを発見
                するのに役に立つ。

                ガーベッジコレクションはすぐには実行されず、安全な場合のみ実行
                される。これはユーザーが文字を入力するのを待っているときであ
                る。ガーベッジコレクションを強制するには、すぐに
                test_garbagecollect_now()を使用すること。

get({list}{idx} [, {default}])                        get()
                リストList {list}から{idx}番目の要素を取得する。この要素を取
                得できないときは{default}を返す。{default}が省略されたときは0
                を返す。
get({dict}{key} [, {default}])
                辞書Dictionary {dict}からキー{key}に関連づけられた値を取得す
                る。この要素を取得できないときは{default}を返す。{default}が省
                略されたときは0を返す。
get({func}{what})
                Funcref {func}から項目を取得する。{what}の可能な値は:
                        "name"  関数名
                        "func"  関数
                        "dict"  辞書
                        "args"  引数リスト

                                                        getbufinfo()
getbufinfo([{expr}])
getbufinfo([{dict}])
                バッファの情報を辞書のリストとして取得する。

                引数なしの場合、すべてのバッファに関する情報が返される。

                引数が辞書の場合、指定された条件を満たすバッファのみが返され
                る。{dict}には以下のキーを指定できる:
                        buflisted       リストされたバッファのみを含む。
                        bufloaded       ロードされたバッファのみを含む。

                それ以外の場合、{expr}は情報を返す特定のバッファを指定する。
                {expr}の使用については、上記のbufname()を参照。バッファが見
                つかった場合、返されるListには1つの項目がある。それ以外の場合、
                結果は空のリストになる。

                返される各List項目は、次のエントリを持つ辞書である:
                        bufnr           バッファ番号。
                        changed         バッファが変更されている場合はTRUE。
                        changedtick     バッファに加えられた変更の数。
                        hidden          バッファが隠されている場合はTRUE。
                        listed          バッファがリストされている場合はTRUE。
                        lnum            バッファ内の現在の行番号。
                        loaded          バッファがロードされている場合はTRUE。
                        name            バッファ内のファイルへのフルパス。
                        signs           バッファに配置された目印のリスト。
                                        各リスト項目は、次のフィールドを含む辞
                                        書である:
                                            id    目印識別子
                                            lnum  行番号
                                            name  目印名
                        variables       バッファローカル変数の辞書への参照。
                        windows         バッファを表示するwindow-IDのリスト

                例:
                        for buf in getbufinfo()
                            echo buf.name
                        endfor
                        for buf in getbufinfo({'buflisted':1})
                            if buf.changed
                                ....
                            endif
                        endfor

                バッファローカルオプションを取得するには:
                        getbufvar({bufnr}, '&')


                                                        getbufline()
getbufline({expr}{lnum} [, {end}])
                バッファ{expr}{lnum}行目から{end}行目まで(両端含む)の行から
                なるリストListを返す。{end}が省略されたときは{lnum}行目だけ
                からなるリストを返す。

                {expr}の指定の仕方についてはbufname()を参照。

                {lnum}{end}では "$" でバッファの最後の行を表すことができる。
                それ以外は数値でなければならない。

                {lnum}が1より小さいときや、バッファの行数より大きいときは空リ
                ストを返す。

                {end}がバッファの行数より大きいときは、バッファの行数が設定さ
                れたものとして扱う。{end}{lnum}行目より前に設定された場合は
                空リストを返す。

                この関数は読み込まれているバッファに対してのみ動作する。既にア
                ンロードされているバッファや存在しないバッファに対しては空リス
                トを返す。

                例:
                        :let lines = getbufline(bufnr("myfile"), 1, "$")

getbufvar({expr}{varname} [, {def}])                          getbufvar()
                バッファ{expr}のオプションの値やバッファローカル変数{varname}
                の値を返す。Note "b:" をつけない変数名を指定すること。
                {varname} が空文字列の場合、全てのバッファローカル変数からなる
                辞書を返す。
                {varname} が "&" に等しいとき、すべてのバッファローカルオプショ
                ンを持つ辞書を返す。
                そうでなく、{varname} が "&" で始まるとき、バッファローカルオ
                プションの値を返す。
                グローバルオプション、バッファローカルオプションのどちらに対し
                ても動作するが、グローバル変数、ウィンドウローカル変数、ウィン
                ドウローカルオプションに対しては動作しない。
                {expr}の指定の仕方についてはbufname()を参照。
                バッファや変数が存在しないときは{def}または空文字列を返し、エ
                ラーメッセージは表示されない。
                例:
                        :let bufmodified = getbufvar(1, "&mod")
                        :echo "todo myvar = " . getbufvar("todo", "myvar")

getchar([expr])                                         getchar()
                ユーザーまたは入力ストリームから1文字を取得する。
                [expr] が省略されたときは1文字を取得できるまで待つ。
                [expr] が0のときは1文字を取得できる場合のみ取得する。取得でき
                なければ0を返す。
                [expr] が1のときは1文字を取得できるか判定し、実際には取得しな
                い。取得できないときは0を返す。

                [expr] が省略されたときや [expr] が0のときは、文字全体または特
                殊キーを返す。それが8ビット文字なら戻り値は数値である。これを
                文字列に戻すにはnr2char()を使う。8ビット文字でないならばエン
                コードして文字列にして返す。
                特殊キーとは0x80(10進数で128)で始まるバイト列である。これは
                文字列 "\<Key>" と同じ値である(例: "\<Left>")。戻り値は文字列
                であり、修飾キー(shift, control, alt)は含まれない。

                [expr] が0や Esc が入力された場合は、これがエスケープシーケン
                スの始まりであるかどうかをVimが知るために待つ間、短い遅延があ
                るだろう。

                [expr] が1のときは最初のバイトだけを返す。1バイト文字の場合、
                これはその文字そのものを表す数値である。これを文字列に変換する
                にはnr2char()を使う。

                修飾キーを取得するには getcharmod() を使う。

                ユーザーがマウスをクリックしたときはマウスイベントを返す。クリッ
                クした位置はv:mouse_colv:mouse_lnumv:mouse_winid,
                v:mouse_winで得られる。以下の例は、普通にマウスがクリックさ
                れたときと同じようにカーソルを移動させる。
                        let c = getchar()
                        if c == "\<LeftMouse>" && v:mouse_win > 0
                          exe v:mouse_win . "wincmd w"
                          exe v:mouse_lnum
                          exe "normal " . v:mouse_col . "|"
                        endif

                bracketed pasteを使用しているときは最初の文字のみが返され、ペー
                ストされた残りのテキストは切り捨てられる。
                xterm-bracketed-paste.

                この関数を呼んだときプロンプトは表示されない。文字入力を待って
                いることをなんらかの方法でユーザーがわかるようにしなければなら
                ないだろう。
                入力された文字に対してマッピングは適用されない。
                キーコードは置換される。つまりユーザーが<Del>を押した場合、
                「生の」文字シーケンスでなく<Del>キーに対応するコードが得られ
                る。
                例:
                        getchar() == "\<Del>"
                        getchar() == "\<S-Left>"
                以下の例は大文字・小文字を区別しないように "f" を再定義する:
                        :nmap f :call FindChar()<CR>
                        :function FindChar()
                        :  let c = nr2char(getchar())
                        :  while col('.') < col('$') - 1
                        :    normal l
                        :    if getline('.')[col('.') - 1] ==? c
                        :      break
                        :    endif
                        :  endwhile
                        :endfunction

                あなたは<CursorHold>のような合成文字も取得するかもしれない。
                多くの場合、あなたはこれを無視して別の文字を取得することにな
                る:
                        :function GetKey()
                        :  let c = getchar()
                        :  while c == "\<CursorHold>"
                        :    let c = getchar()
                        :  endwhile
                        :  return c
                        :endfunction

getcharmod()                                            getcharmod()
                最後にgetchar()などで得た文字に対する修飾キーの状態を表す数値
                を返す。以下の値の和となる:
                        2       shift
                        4       control
                        8       alt (meta)
                        16      meta (ALT と META が区別される場合)
                        32      マウスのダブルクリック
                        64      マウスのトリプルクリック
                        96      マウスのクアドラプルクリック (== 32 + 64)
                        128     command (Macintosh のみ)
                文字自身に含まれていない修飾キーのみ取得できる。つまり、
                Shift-aは修飾キーなしの "A" となる。

getcharsearch()                                         getcharsearch()
                現在の文字検索の情報である{dict}を返し、この辞書は下記のエント
                リを持つ:

                    char        文字検索(tfTF)で以前に使われた文字。
                                もし文字検索が実行されていないなら空文字列。
                    forward     文字検索の方向。1は前方、0は後方。
                    until       文字検索の種類。1はtもしくはTの文字検索、0は
                                fもしくはFの文字検索。

                下記の設定は前回の文字検索の方向に関わらず、; で前方検索、
                , で後方検索を常に行えるようになり便利である:
                        :nnoremap <expr> ; getcharsearch().forward ? ';' : ','
                        :nnoremap <expr> , getcharsearch().forward ? ',' : ';'
                setcharsearch()も参照。

getcmdline()                                            getcmdline()
                現在のコマンドラインの内容を取得する。コマンドラインを編集して
                いるときのみ動作する。つまりc_CTRL-\_eまたはc_CTRL-R_=を使っ
                ているときのみ有効。
                例:
                        :cmap <F7> <C-\>eescape(getcmdline(), ' \')<CR>
                getcmdtype()getcmdpos()setcmdpos()も参照。

getcmdpos()                                             getcmdpos()
                コマンドラインにおけるカーソル位置をバイト単位で取得する。最初
                の桁は1となる。コマンドラインを編集しているときのみ動作する。
                つまりc_CTRL-\_eまたはc_CTRL-R_=または式マッピングを使って
                いるときのみ有効。そうでないときは 0 を返す。
                getcmdtype()setcmdpos()getcmdline()も参照。

getcmdtype()                                            getcmdtype()
                現在のコマンドラインの種類を返す。戻り値は次のいずれか:
                    :   通常のexコマンド
                    >   デバッグモードコマンド debug-mode
                    /   前方検索コマンド
                    ?   後方検索コマンド
                    @   input() コマンド
                    -   :insert または :append コマンド
                    =   i_CTRL-R_=
                コマンドラインを編集しているときのみ動作する。つまり
                c_CTRL-\_eまたはc_CTRL-R_=または式マッピングを使っていると
                きのみ有効。そうでないときは空文字列を返す。
                getcmdpos()setcmdpos()getcmdline()も参照。

getcmdwintype()                                         getcmdwintype()
                現在のコマンドラインウィンドウ (command-line-window) の種類
                を返す。戻り値の意味は getcmdtype() と同じ。コマンドライン
                ウィンドウでなければ空文字列を返す。

getcompletion({pat}{type} [, {filtered}])             getcompletion()
                コマンドライン補完のマッチするリストを返す。{type}は何のための
                ものかを指定する。 次の補完タイプがサポートされている:

                augroup         自動コマンドグループ
                buffer          バッファ名
                behave          :behaveサブオプション
                color           カラースキーム
                command         Exコマンド (および引数)
                compiler        コンパイラ
                cscope          :cscopeのサブオプション
                dir             辞書名
                environment     環境変数名
                event           自動コマンドのイベント
                expression      Vim式
                file            ファイルおよびディレクトリ名
                file_in_path    'path'のファイルおよびディレクトリ名
                filetype        ファイルタイプ名 'filetype'
                function        関数名
                help            ヘルプ項目
                highlight       ハイライトグループ
                history         :historyサブオプション
                locale          ロケール名 (locale -aの出力)
                mapping         マッピング名
                menu            メニュー
                messages        :messagesサブオプション
                option          オプション
                packadd         任意パッケージ pack-add 名
                shellcmd        シェルコマンド
                sign            :signサブオプション
                syntax          構文ファイル名 'syntax'
                syntime         :syntimeサブオプション
                tag             タグ
                tag_listfiles   タグ、ファイル名
                user            ユーザー名
                var             ユーザー変数

                {pat}が空文字列の場合、すべてのマッチが返される。それ以外の場
                合、{pat}と一致する項目のみが返される。{pat}での特殊文字の使用
                については、wildcardsを参照。

                オプションの{filtered}フラグが1に設定されている場合、結果をフィ
                ルタリングするために 'wildignore'が適用される。そうでなければ、
                すべての一致が返される。'wildignorecase'オプションは常に適用さ
                れる。

                一致するものがなければ、空のリストが返される。{type}の値が無効
                だと、エラーが発生する。

                                                        getcurpos()
getcurpos()     カーソルの位置を返す。これは getpos('.') に似ているが、追加の
                情報を含む:
                    [bufnum, lnum, col, off, curswant]
                "curswant" は縦方向移動の優先的列番号である。
                次のようにしてカーソル位置の保存と復元ができる:
                        let save_cursor = getcurpos()
                        MoveTheCursorAround
                        call setpos('.', save_cursor)

                                                        getcwd()
getcwd([{winnr} [, {tabnr}]])
                結果は現在の作業ディレクトリ名の文字列である。
                引数が指定されない場合、現在のウィンドウである。

                {winnr}が指定された場合、現在のタブページ内の{winnr}のウィンド
                ウのローカルカレントディレクトリを返す。
                {winnr}{tabnr}が指定された場合、{tabnr}のタブページ内の
                {winnr}のウィンドウのローカルカレントディレクトリを返す。
                {winnr} にはウィンドウ番号またはwindow-IDが使える。
                もし引数が不正の場合、空文字列を返す。

getfsize({fname})                                       getfsize()
                結果は数値で、{fname}で指定されるファイルのサイズをバイト単位
                で返す。
                {fname}がディレクトリのときは0を返す。
                ファイル{fname}が見つからないときは-1を返す。
                {fname} のサイズが Number の範囲外の場合は -2 を返す。

getfontname([{name}])                                   getfontname()
                引数なしで使われた場合には現在の通常のフォント名を返す。ハイラ
                イトグループNormalに対して使われるものと同様hl-Normal
                引数が指定された場合には{name}が有効なフォント名であるか判定さ
                れる。有効でないときは空文字列を返す。
                有効なときは実際のフォント名を返す。またはGUIが実際の名前の取
                得をサポートしていないときは{name}をそのまま返す。
                GUIモードで実行しているときのみ動作する。よってvimrcやgvimrcの
                中では使えない。GUIモードが起動した直後にこの関数を呼ぶには、
                オートコマンドGUIEnterを使うこと。
                Note GTKのGUIはどんなフォント名でも受け付けてしまうため、名前
                が有効であるかのチェックは機能しない。

getfperm({fname})                                       getfperm()
                {fname}で指定されたファイルの読み込み、書き込み、実行の許可属
                性を示す文字列を返す。
                {fname}が存在しない、またはそのディレクトリが読み込み不可能な
                ときは空文字列を返す。
                戻り値は "rwxrwxrwx" の形で、"rwx" フラグの各グループは順にファ
                イルの所有者、ファイルが所属するグループ、その他のユーザーを表
                す。許可属性が与えられていないフラグは "-" で置き換えられる。
                例:
                        :echo getfperm("/etc/passwd")
                        :echo getfperm(expand("~/.vimrc"))
                この例は、(セキュリティの観点から望ましい設定がされているなら
                ば) "rw-r--r--" あるいは "rw-------" と表示する。

                許可属性を設定するにはsetfperm()を使用する。

                                                        getftime()
getftime({fname})
                結果は{fname}で与えられたファイルの、最終更新時間を示す数値。
                1970年1月1日からの経過時間(秒)で、strftime()に渡すことができる
                だろう。localtime()strftime()も参照。
                ファイル{fname}が見つからなかった場合には-1を返す。

getftype({fname})                                       getftype()
                {fname}で指定されたファイルの種別を示す文字列を返す。
                {fname}が存在しないときは空文字列を返す。
                ファイルの種別とそれらの結果の表を以下に示す:
                        通常ファイル            "file"
                        ディレクトリ            "dir"
                        シンボリックリンク      "link"
                        ブロックデバイス        "bdev"
                        キャラクタデバイス      "cdev"
                        ソケット                "socket"
                        FIFO                    "fifo"
                        それ以外                "other"
                例:
                        getftype("/home")
                Note "link" などの種別はそれをサポートしているシステムでのみ返
                される。"dir" と "file" しか返らないシステムもある。
                MS-Windowsでは、ディレクトリへのシンボリックリンクは "link" の
                代わりに "dir" を返す。

                                                        getline()
getline({lnum} [, {end}])
                {end}が指定されない場合は、カレントバッファの{lnum}行目の内容
                を文字列にして返す。例:
                        getline(1)
                {lnum}が数字ではない文字で始まる文字列であった場合、line()に
                よってその文字列が数字に変換される。よって、カーソルのある行の
                文字列を取得するには:
                        getline(".")
                {lnum}が1より小さいかバッファの行数よりも大きい数値の場合、空
                文字列が返される。

                {end}が指定された場合は、カレントバッファの{lnum}行目から
                {end}行目までを要素とするリストListを返す。
                {end}{lnum}と同様に解釈される。
                存在しない行は省略され、エラーメッセージは表示されない。
                {end}{lnum}より前になる場合は空リストを返す。
                例:
                        :let start = line('.')
                        :let end = search("^$") - 1
                        :let lines = getline(start, end)

                他のバッファの行を取得するにはgetbufline()を参照。

getloclist({nr}[, {what}])                              getloclist()
                ウィンドウ{nr}のロケーションリストの全項目からなるリストを返す。
                {nr} にはウィンドウ番号またはwindow-IDが使える。{nr}に0を指
                定するとカレントウィンドウになる。

                ロケーションリストウィンドウに対して使用すると、そこに表示され
                ているロケーションリストが返る。ウィンドウ番号{nr}が無効な場合
                は、空リストが返る。それ以外はgetqflist()と同じ。

                オプションの{what}辞書引数が指定されている場合、{what}にリスト
                されている項目を辞書として返す。{what}のサポートされている項目
                については、getqflist()を参照。

getmatches()                                            getmatches()
                matchadd() と :match により定義された全てのマッチの List
                を返す。setmatches() は getmatches() で保存されたマッチの
                リストを復元できるので、getmatches() と setmatches() は組
                み合わせて使うと便利である。
                例:
                        :echo getmatches()
                        [{'group': 'MyGroup1', 'pattern': 'TODO',
                        'priority': 10, 'id': 1}, {'group': 'MyGroup2',
                        'pattern': 'FIXME', 'priority': 10, 'id': 2}]
                        :let m = getmatches()
                        :call clearmatches()
                        :echo getmatches()
                        []
                        :call setmatches(m)
                        :echo getmatches()
                        [{'group': 'MyGroup1', 'pattern': 'TODO',
                        'priority': 10, 'id': 1}, {'group': 'MyGroup2',
                        'pattern': 'FIXME', 'priority': 10, 'id': 2}]
                        :unlet m

                                                        getpid()
getpid()        Vim のプロセス ID を数値で返す。Unix と MS-Windows では Vim が
                終了するまでこれは一意な数値である。MS-DOS では常にゼロである。

                                                        getpos()
getpos({expr})  {expr}の位置を返す。{expr}として指定できる値については
                line()を参照。カーソル位置を得るには getcurpos() を参照。
                結果は次の4個の要素を持つリストList:
                    [bufnum, lnum, col, off]
                "bufnum" は、'0 や 'A のようなマークが指定されたときは、その
                マークのバッファ番号となる。それ以外では0となる。
                "lnum" と "col" はバッファ中の位置。桁番号は1から始まる。
                "off" の値は、'virtualedit' がオフのときは常に0で、オンのとき
                はその文字の始点からの画面上の桁のオフセットである。つまり、
                カーソルが<Tab>の中や、その行の最後の文字より後にあるとき意味
                を持つ。
                Note: ビジュアルモードの '< と '> について: ビジュアルモードが
                "V" (行選択モード) のとき、'< の桁番号はゼロ、'> の桁番号は大
                きな値になる。
                この関数はマークの位置を保存し、復元するために使われる:
                        let save_a_mark = getpos("'a")
                        ...
                        call setpos("'a", save_a_mark)
                getcurpos() と setpos()も参照。


getqflist([{what}])                                     getqflist()
                現在の全quickfixエラーのリストを返す。リストの各要素は辞書で、
                以下の要素を持つ:
                        bufnr   ファイル名を持つバッファの番号。その名前を取得
                                するにはbufname()を使う。
                        lnum    バッファ中の行番号(最初の行は1)
                        col     桁番号(最初の桁は1)
                        vcol    TRUE: "col" は画面上の桁
                                FALSE: "col" はバイトインデックス
                        nr      エラー番号
                        pattern エラーの位置を特定するために使う検索パターン
                        text    エラーの説明
                        type    エラーメッセージの種類。'E', '1' など。
                        valid   TRUE: エラーメッセージが認識されている

                エラーリストがまったくないか、空であるときは空リストを返す。
                存在しないバッファ番号を持つquickfixリストの項目は "bufnr" を0
                にして返される。

                役に立つ応用例: 複数のファイルから正規表現検索を行い、見つかっ
                たものに対してなんらかの操作をする:
                        :vimgrep /theword/jg *.c
                        :for d in getqflist()
                        :   echo bufname(d.bufnr) ':' d.lnum '=' d.text
                        :endfor

                オプションの{what}辞書引数が指定されている場合は、{what}にリス
                トされている項目のみを辞書として返す。{what}では、以下の文字列
                項目がサポートされている:
                        nr      このquickfixリストの情報を取得。0 は現在の
                                quickfixリストを意味する
                        title   リストタイトルを取得
                        winid   window-IDを取得 (もし開かれていれば)
                        all     上記のquickfixのすべてのプロパティ
                {what}の文字列以外の項目は無視される。
                "nr" が存在しない場合、現在のquickfixリストが使用される。{what}
                の処理中にエラーとなった場合、空の辞書が返される。

                返される辞書には、次のエントリが含まれる:
                        nr      quickfixリスト番号
                        title   quickfixリストのタイトルテキスト
                        winid   quickfixのwindow-ID (もし開かれていれば)

                例:
                        :echo getqflist({'all': 1})
                        :echo getqflist({'nr': 2, 'title': 1})


getreg([{regname} [, 1 [, {list}]]])                    getreg()
                レジスタ{regname}の中身を文字列にして返す。例:
                        :let cliptext = getreg('*')
                {regname} がセットされていないときは、結果は空文字列となる。
                getreg('=')は最後に評価した式レジスタの値を返す。(マップの中で
                使用する)。
                getreg('=', 1)はその式そのものを返す。これを使ってsetreg()
                復元することができる。他のレジスタの場合は、この引数は無視され
                るので、常に指定していても害はない。
                {list} が指定され、その値がTRUEのときは、戻り値はリスト
                (List) になる。リストの各要素はテキスト 1 行である。これはレ
                ジスタの中に値ゼロのバイトが含まれる場合に使用する。{list} を
                指定しなかった場合は NL 文字と値ゼロのバイトは両方とも NL 文字
                として扱われる (NL-used-for-Nul 参照)。
                指定したレジスタがセットされていないときは、空のリストが返され
                る。
                {regname}を指定しないときはv:registerが使われる。


getregtype([{regname}])                                 getregtype()
                レジスタ{regname}の種類を表す文字列を返す。
                戻り値は次のいずれかとなる:
                    "v"                 文字単位characterwiseの場合
                    "V"                 行単位linewiseの場合
                    "<CTRL-V>{width}"   矩形blockwise-visualの場合
                    ""                  空、または未知のレジスタの場合
                <CTRL-V>は値0x16の1文字である。
                {regname}を指定しないときはv:registerが使われる。

gettabinfo([{arg}])                                     gettabinfo()
                {arg}を指定しないと、すべてのタブページに関する情報がリストと
                して返される。各リスト項目は辞書である。それ以外の場合、{arg}
                はタブページ番号を指定し、それに関する情報が返される。タブペー
                ジが存在しない場合、空のリストが返される。

                各リストアイテムは、次のエントリを持つ辞書である:
                        tabnr           タブページ番号。
                        variables       タブページローカル変数の辞書への参照。
                        windows         タブページのwindow-IDのリスト。

gettabvar({tabnr}{varname} [, {def}])                         gettabvar()
                タブページ {tabnr} のタブローカル変数 {varname} を取得する。
                t:var
                タブの番号は 1 から始まる。
                {varname} が空のときは全タブローカル変数からなる辞書を返す。
                Note: 指定する変数名は "t:" を除いた名前。
                タブや変数が存在しないときは{def}または空文字列を返し、エラー
                メッセージは表示されない。

gettabwinvar({tabnr}{winnr}{varname} [, {def}])             gettabwinvar()
                タブページ{tabnr}内のウィンドウ{winnr}のウィンドウローカル変数
                {varname}の値を取得する。
                {varname}が空のときは全ウィンドウローカル変数からなる辞書を返
                す。
                {varname}が "&" と等しい場合はすべてのウィンドウローカルオプ
                ションの値を辞書に入れて返す。
                {varname}が文字 "&" で始まるときはウィンドウローカルオプション
                の値を取得する。
                Note {varname}は "w:" をつけずに指定しなければならない。
                タブページ番号は1から始まる。カレントタブページを指定するには
                getwinvar()を指定する。
                {winnr} にはウィンドウ番号またはwindow-IDが使える。
                {winnr}が0のときはカレントウィンドウとなる。
                グローバルオプション、バッファローカルオプション、ウィンドウ
                ローカルオプションに対しても動作するが、グローバル変数やバッ
                ファローカル変数に対しては動作しない。
                ウィンドウやタブや変数が存在しないときは{def}または空文字列を
                返し、エラーメッセージは表示されない。
                例:
                        :let list_is_on = gettabwinvar(1, 2, '&list')
                        :echo "myvar = " . gettabwinvar(3, 1, 'myvar')


                                                        getwinposx()
getwinposx()    結果はGUIのVimウィンドウの左端の、デスクトップ上でのX座標値(数
                値)。情報が存在しない(コンソールの)場合は-1となる。

                                                        getwinposy()
getwinposy()    結果はGUIのVimウィンドウの上端の、デスクトップ上でのY座標値(数
                値)。情報が存在しない(コンソールの)場合は-1となる。

getwininfo([{winid}])                                   getwininfo()
                ウィンドウに関する情報を、辞書のリストとして返す。

                {winid}が与えられた場合、そのIDを持つウィンドウに関する情報が
                返される。ウィンドウが存在しない場合、結果は空のリストになる。

                {winid}がなければすべてのタブページのすべてのウィンドウに関す
                る情報が返される。

                各Listアイテムは次のエントリを持つ辞書である:
                        bufnr           ウィンドウ内のバッファ数
                        height          ウィンドウの高さ
                        loclist         ロケーションリストを表示してる場合は1
                                        {Vimが+quickfix機能付きでコンパイルさ
                                        れたときのみ有効}
                        quickfix        quickfixまたはロケーションリストウィン
                                        ドウの場合は1
                                        {Vimが+quickfix機能付きでコンパイルさ
                                        れたときのみ有効}
                        tabnr           タブページ番号
                        variables       ウィンドウローカル変数の辞書への参照
                        width           ウィンドウ幅
                        winid           window-ID
                        winnr           ウィンドウ番号

                すべてのウィンドウローカル変数を取得するには:
                        gettabwinvar({tabnr}, {winnr}, '&')

getwinvar({winnr}{varname} [, {def}])                         getwinvar()
                カレントタブページに対するgettabwinvar()と同様。
                例:
                        :let list_is_on = getwinvar(2, '&list')
                        :echo "myvar = " . getwinvar(1, 'myvar')

glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])              glob()
                {expr}内のファイル名のワイルドカードを展開する。特殊文字につい
                てはwildcardsを参照。

                {nosuf} にTRUEを指定しない限り、'suffixes' と 'wildignore'
                が適用される。つまり 'wildignore' のパターンにマッチする名前は
                スキップされ、'suffixes' がマッチの順番に影響を与える。
                'wildignorecase' は常に適用される。

                {list} が指定されその値がTRUEなら、マッチしたすべてのファイ
                ルがリストとして返される。リストを使うことで、改行を含むファイ
                ル名があっても結果を正しく受け取ることができる。
                そうでない場合は結果は文字列で返される。その場合、複数のマッチ
                があるときはそれらは文字 <NL> で区切られる。

                展開が失敗した場合、空の文字列またはリストが返される。
                
                存在しないファイル名は結果に含まれない。シンボリックリンクは、
                それが存在するファイルを指す場合のみ含まれる。
                ただし、{alllinks} 引数が存在し、それがTRUEである場合はすべ
                てのシンボリックリンクが含まれる。

                多くのシステムではバッククォート(「`」という文字のこと)を、外
                部コマンドの実行結果からファイル名を取得するために使用できる。
                例:
                        :let tagfiles = glob("`find . -name tags -print`")
                        :let &tags = substitute(tagfiles, "\n", ",", "g")
                バッククォート内のプログラムの実行結果は、一行に一つずつの項目
                が含まれてなければならない。項目内のスペースは許容される。
                
                特殊なVimの変数を展開するためにはexpand()を参照。外部コマン
                ドの生の出力を得るためにはsystem()を参照。

glob2regpat({expr})                                      glob2regpat()
                glob()に使われるファイルパターンを検索パターンに変換する。
                結果はファイル名の文字列とのマッチに使用できる。例えば、
                        if filename =~ glob2regpat('Make*.mak')
                上記は次と同じである:
                        if filename =~ '^Make.*\.mak$'
                {expr}が空文字列の場合、結果は "^$" で、空文字列にマッチする。
                結果はシステムによって異なることに注意すること。MS-Windowsで
                は、バックスラッシュは通常、パス区切りを意味する。

                                                                globpath()
globpath({path}{expr} [, {nosuf} [, {list} [, {alllinks}]]])
                {path}の中の全ディレクトリに対してglob()を実行し、結果を連結
                する。例:
                        :echo globpath(&rtp, "syntax/c.vim")

                {path}はコンマ区切りのディレクトリのリスト。各ディレクトリを
                {expr}の前に付加し、glob()と同様にそれを展開する。必要に応じて
                パスの区切り文字が挿入される。
                ディレクトリ名の中にコンマを含めるには、バックスラッシュでエス
                ケープすること。Note MS-Windowsではディレクトリ名の末尾にバッ
                クスラッシュがつくことがある。その後に区切りのコンマを書くとエ
                スケープと見なされてしまうので、バックスラッシュは削除すること。
                どれかのディレクトリに対して展開が失敗してもエラーメッセージは
                表示されない。

                {nosuf} にTRUEが指定されない限り、オプション 'wildignore' が
                適用される。つまり、'wildignore' のパターンにマッチする名前は
                スキップされる。

                {list} が指定され、その値がTRUEなら、マッチしたすべてのファ
                イルがリストとして返る。リストとして受け取る利点は、改行文字を
                含んだファイル名も正しく扱えることである。{list} を指定しな
                かった場合は、戻り値は文字列であり、マッチした複数のファイル名
                は <NL> 文字で連結されてしまう。例:
                        :echo globpath(&rtp, "syntax/c.vim", 0, 1)

                {alllinks} はglob()の場合と同様に扱われる。

                "**" を使ってディレクトリツリーを再帰的に検索することができる。
                例えば、'runtimepath' とそれ以下のディレクトリから全ての
                "README.txt" を探すには次のようにする:
                        :echo globpath(&rtp, "**/README.txt")
                上向き検索と、"**" の深さの限界はサポートされていない。よって
                オプション 'path' の値をそのまま使うとうまく動かないことが
                ある。

                                                        has()
has({feature})  結果は機能{feature}がサポートされる場合1、されない場合0とな
                る。引数{feature}は文字列。下記のfeature-listを参照。
                exists()も参照。

has_key({dict}{key})                                  has_key()
                結果は数値で、辞書Dictionary {dict}がキー{key}の要素を持つな
                ら1、持たないなら0となる。

haslocaldir([{winnr} [, {tabnr}]])                      haslocaldir()
                結果は数値でウィンドウが:lcdによってローカルなカレントディレ
                クトリを持つようセットされているなら1、そうでないなら0となる。

                引数が指定されない場合、現在のウィンドウを対象とする。
                {winnr}が指定された場合、現在のタブページ内の{winnr}のウィンド
                ウを対象とする。
                {winnr}{tabnr}が指定された場合、{tabnr}のタブページ内の
                {winnr}のウィンドウを対象とする。
                {winnr} にはウィンドウ番号またはwindow-IDが使える。
                もし引数が不正の場合、0 を返す。

hasmapto({what} [, {mode} [, {abbr}]])                  hasmapto()
                結果は数値。右辺側(マップした先)の一部分に{what}を含むマッピン
                グが存在し、それが{mode}で指定されたモードのいずれかで定義され
                ているなら1を返す。
                {abbr}が指定されていてTRUEのときはマッピングでなく短縮入力の
                存在を判定する。挿入モードまたはコマンドモードを指定することを
                忘れないように。
                グローバルマップとバッファローカルマップの両方をチェックする。
                マッピングが1個も見つからなかったときは0を返す。
                {mode}に対しては以下の文字が利用できる:
                        n       ノーマルモード
                        v       ビジュアルモード
                        o       オペレータ待機モード (Operator-pending)
                        i       挿入モード
                        l       Language-Argumentモード ("r", "f", "t" など)
                        c       コマンドラインモード
                {mode}が省略されたときは "nvo" となる。

                この関数はVim scriptの中で、ある関数へのマッピングが既に存在す
                るか判定するために有用である。例:
                        :if !hasmapto('\ABCdoit')
                        :   map <Leader>d \ABCdoit
                        :endif
                この例は、"\ABCdoit" へのマッピングが存在しないときだけ
                "\ABCdoit" へのマッピングを作成する。

histadd({history}{item})                              histadd()
                文字列{item}を履歴{history}に追加する。履歴{history}は以下のう
                ちどれか一つから選択:                   hist-names
                        "cmd"    or ":"   コマンドライン履歴
                        "search" or "/"   検索パターン履歴
                        "expr"   or "="   タイプされた式の履歴
                        "input"  or "@"   input()の履歴
                        "debug"  or ">"   デバッグコマンドの履歴
                {history} 文字列はフルネームで指定する必要はありません。頭文字
                だけでも構いません。
                {item}が履歴内に既に存在する場合、それが最新の項目の位置へシフ
                トされる。結果は数値:操作が成功した場合1、そうでなければ0

                例:
                        :call histadd("input", strftime("%Y %b %d"))
                        :let date=input("Enter date: ")
                サンドボックスsandboxの中では利用できない。

histdel({history} [, {item}])                           histdel()
                {history}の内容を削除する。例えば全てのエントリを消すこともで
                きる。{history}の部分に可能な値はhist-namesを参照。

                パラメーター{item}が文字列に評価される場合、これは正規表現と
                して扱われる。その表現にマッチする全てのエントリがhistoryから
                削除される(複数あっても)。
                "\c" をつけない場合、大文字・小文字が一致しなければならない。
                /\c
                {item}が数値に評価される場合、インデックスとして解釈される。イ
                ンデックスについては:history-indexingを参照。関連するエント
                リ{訳注: The respective entry}も、存在すれば削除される。

                結果は数値: 削除に成功すれば1を、そうでなければ0が返る。

                例:
                式レジスタの履歴を削除する:
                        :call histdel("expr")

                検索履歴から、"*" で始まるエントリを全て削除する:
                        :call histdel("/", '^\*')

                次の3つは等価である:
                        :call histdel("search", histnr("search"))
                        :call histdel("search", -1)
                        :call histdel("search", '^'.histget("search", -1).'$')

                最後の検索パターンを削除し、一つ前のパターンを "n" コマンド(次
                のマッチへ移動)と 'hlsearch' の為に設定する:
                        :call histdel("search", -1)
                        :let @/ = histget("search", -1) 

histget({history} [, {index}])                          histget()
                結果は{history}の第{index}エントリを表わす文字列。{history} の
                部分に可能な値はhist-namesを、{index}については
                :history-indexingを参照。指定されたエントリが存在しない場合
                は空文字列が返される。{index}が省略された場合には、履歴中の最
                新のエントリが戻り値として使用される。

                例:
                2つ前に行われた検索をやり直す:
                        :execute '/' . histget("search", -2)

                :historyによって出力される{num}番目のエントリを、再度実行す
                るための ":H {num}" というコマンドを定義する。
                        :command -nargs=1 H execute histget("cmd",0+<args>)

histnr({history})                                       histnr()
                結果は数値で{history}の現在のエントリ数。{history}の部分に可能
                な値はhist-namesを参照。エラーが起こった場合、-1が返される。

                例:
                        :let inp_index = histnr("expr")

hlexists({name})                                        hlexists()
                結果は数値で、{name}という名のハイライトグループが存在すれば、
                非ゼロの値が返される。これはなんらかの方法でそのグループが既に
                定義されている時にのみ起こる。これの為に実際に何らかのハイライ
                ティングアイテムが設定されている必要はなく、単に構文アイテムと
                しても使われるだろう。
                                                        highlight_exists()
                以前の名前: highlight_exists().

                                                        hlID()
hlID({name})    結果は数値で、{name}という名前のハイライトグループのID番号。そ
                のハイライトグループが存在しない場合は0が返される。
                これはハイライトグループについての情報を獲得するために使用され
                る。例えば "Comment" グループの背景色を取得するにはこのように
                する:
        :echo synIDattr(synIDtrans(hlID("Comment")), "bg")
                                                        highlightID()
                以前の名前: highlightID()

hostname()                                              hostname()
                結果は文字列で、現在Vimが実行されているマシンの名前。名前が256
                文字を超える場合、超えた部分は切り捨てられる。

iconv({expr}{from}{to})                             iconv()
                文字列{expr}をエンコーディング{from}からエンコーディング{to}
                変換した文字列を返す。
                変換が完全に失敗したときは空文字列を返す。一部の文字が変換でき
                なかった場合、その文字は "?" に置き換わる。
                エンコーディング名はライブラリ関数iconv()が受け付けるものなら
                なんでもよい。":!man 3 iconv" を参照。
                ほとんどの変換は、Vimが+iconv機能つきでコンパイルされている
                ときのみ利用可能。+iconvつきでないときもUTF-8からlatin1への
                変換とその逆は行える。
                オプション 'encoding' の値に関係なく、特殊な文字を含むメッセー
                ジを表示するために使える。UTF-8でエンコードされたメッセージを
                表示するには次のようにする:
                        echo iconv(utf8_str, "utf-8", &enc)
                Note Vimは全てのUnicodeエンコーディングに対してUTF-8を使う。
                UCS-2との変換を行おうとしても、自動的にUTF-8との変換に変更され
                る。いずれにせよ、UCS-2はNULバイトを含むため、文字列にUCS-2を
                使うことはできない。
                {+multi_byte 機能付きでコンパイルされたときのみ利用可能}

                                                        indent()
indent({lnum})  カレントバッファの{lnum}行目のインデント量を数値で返す。この
                インデント量はスペース単位で数えられ、'tabstop' の値が関係する。
                {lnum}getline()の場合と同様に扱われる。
                {lnum}が無効なときは-1を返す。


index({list}{expr} [, {start} [, {ic}]])                      index()
                リストList {list}の中で、{expr}に等しい要素の最小のインデッ
                クスを返す。自動的な変換は行われないので、文字列の "4" は数値
                の 4 とは異なると判定される。そして数値の 4 は浮動小数点数の
                4.0 とも異なる。'ignorecase' はここでは適用されず、常に大文字・
                小文字は区別される。
                {start}が指定された場合はインデックス{start}から要素の検索を始
                める(負数を指定すると末尾からの相対位置となる)。
                {ic}TRUEが指定された場合、大文字・小文字は区別されない。
                そうでない場合は区別される。
                {list}の中に{expr}が見つからない場合は-1を返す。
                例:
                        :let idx = index(words, "the")
                        :if index(numbers, 123) >= 0

input({prompt} [, {text} [, {completion}]])             input()
                結果は文字列で、ユーザーがコマンドラインに入力したものが返され
                る。引数 {prompt} にはプロンプト文字列か空文字列を指定する。空
                文字列の場合はプロンプトなしになる。'\n' を使ってプロンプトに
                改行を含めることができる。
                :echohlによるハイライトの設定がプロンプトに適用される。
                入力はコマンドラインと同様に行え、同じ編集コマンドやキーマップ
                が使用できる。input()に入力された文字列には、他の履歴とは独立
                した履歴が与えられる。
                例:
                        :if input("Coffee or beer? ") == "beer"
                        :  echo "Cheers!"
                        :endif

                省略可能な引数{text}が与えられ、空でないならば、それが入力の初
                期値として、ユーザーが入力したのと同じ様に表示される。例:
                        :let color = input("Color? ", "white")

                省略可能な引数{completion}はこの入力において利用できる補完の種
                類を指定する。この引数がないときは補完は行われない。対応してい
                る補完の種類は、ユーザー定義コマンドにおいて引数 "-complete="
                で指定するものと同じである。詳しくは:command-completionを参
                照。
                例:
                        let fname = input("File: ", "", "file")

                NOTE: この関数はGUIモードしか持たないバージョン(例、Win32 GUI)
                のVimでは、スタートアップファイルの中で使用することはできな
                い。
                NOTE: マッピングの中からinput()を呼ぶと、そのマッピングの残り
                の文字が消費される。マッピングは、その文字が入力されたときと同
                じように処理されるためである。
                これを避けるには、input()の前にinputsave()を呼び、input()の
                後にinputrestore()を呼ぶ。もう1つの対策は、:execute
                :normalを使うなどして、そのマッピングでそれ以上文字を続けな
                いようにすることである。

                マッピングと同時に使う例:
                        :nmap \x :call GetFoo()<CR>:exe "/" . Foo<CR>
                        :function GetFoo()
                        :  call inputsave()
                        :  let g:Foo = input("enter search pattern: ")
                        :  call inputrestore()
                        :endfunction

inputdialog({prompt} [, {text} [, {cancelreturn}]])             inputdialog()
                input()と同様。GUIで動作していて、テキストダイアログがサポー
                トされている場合はダイアログを表示してテキストを入力させる。
                例:
                   :let n = inputdialog("value for shiftwidth", shiftwidth())
                   :if n != ""
                   :  let &sw = n
                   :endif
                ダイアログがキャンセルされたときは{cancelreturn}を返す。
                {cancelreturn}が省略されているときは空文字列を返す。
                <Enter>を押すとOKボタンを押すのと同じ動作になる。<Esc>を押すと
                キャンセルボタンを押すのと同じ動作になる。
                NOTE: コマンドライン補完は対応していない。

inputlist({textlist})                                   inputlist()
                {textlist}は文字列のリストListでなければならない。1行につき
                リストの要素を1個表示し、ユーザーに数字を入力するよう促す。入
                力された数字を返す。
                ユーザーはマウスで文字列をクリックすることでも選択できる。最初
                の文字列を選択すると0が返る。最初の文字列より上をクリックする
                と負数が返る。プロンプト自身をクリックすると{textlist}の長さ+1
                が返る。
                {textlist}の要素数はオプション 'lines' の値より少なくなければ
                ならない。そうでないと動作しない。最初の要素にメッセージを書
                き、各文字列の先頭に番号をつけておくとよい。
                例:
                        let color = inputlist(['Select color:', '1. red',
                                \ '2. green', '3. blue'])

inputrestore()                                          inputrestore()
                前回のinputsave()で保存しておいた先行入力を復元する。
                inputsave()と同じ回数だけ呼ぶようにしなければならない。しかし
                多く呼びすぎても害はない。復元するものがなければ1を、そうでな
                ければ0を返す。

inputsave()                                             inputsave()
                先行入力(マッピングにより入力された文字も含む)を保存し、クリア
                することにより、これ以降のプロンプトがユーザーからの入力を得る
                ようにする。プロンプトの後で、対応するinputrestore()を呼び出さ
                ねばならない。複数回呼ぶこともできる。ただしその場合は同じ回数
                だけinputrestore()を呼ばなくてはならない。
                メモリ不足のときは1を、そうでなければ0を返す。

inputsecret({prompt} [, {text}])                        inputsecret()
                input()とほぼ同じだが、以下の2点が異なる:
                a) ユーザーの入力をアスタリスク("*")の列として表示し、入力内容
                を読めないようにする。
                b) ユーザーの入力が入力履歴historyに残らない。
                ユーザーの入力内容を文字列として返す。
                NOTE: コマンドライン補完には対応していない。

insert({list}{item} [, {idx}])                        insert()
                リストList {list}の初めに{item}を挿入する。
                {idx}が指定されたときはインデックス{idx}の要素の前に{item}を挿
                入する。{idx}が0のときは{idx}を省略した場合と同じ様に最初の要
                素の前に挿入する。{idx}は負数でもよい(list-index参照)。-1を
                指定すると最後の要素の前に挿入する。
                挿入した結果のリストを返す。例:
                        :let mylist = insert([2, 3, 5], 1)
                        :call insert(mylist, 4, -1)
                        :call insert(mylist, 6, len(mylist))
                最後の例はadd()を使うともっと簡単に書ける。
                Note {item}がリストの場合は、1個の要素として追加される。リスト
                を連結するにはextend()を使うこと。

invert({expr})                                          invert()
                ビット反転。引数は数値に変換される。リスト、辞書、浮動小数点数
                を指定するとエラーになる。例:
                        :let bits = invert(bits)

isdirectory({directory})                                isdirectory()
                結果は数値で、{directory}という名前のディレクトリが存在すれば
                TRUEとなる。{directory}が存在しないか、存在したとしても
                ディレクトリではなかった場合には、FALSEが返される。文字列と
                して解釈できるのならば{directory}の表現はどのようなもので
                あってもかまわない。

islocked({expr})                                        islocked() E786
                結果は数値で、{expr}がロックされている変数の名前ならばTRUE
                返す。
                {expr}は変数の名前、リストの要素、辞書の要素のいずれかでなけれ
                ばならない。変数そのものを指定しないように注意。例:
                        :let alist = [0, ['a', 'b'], 2, 3]
                        :lockvar 1 alist
                        :echo islocked('alist')         " 1
                        :echo islocked('alist[1]')      " 0

                {expr}が存在しない変数のときはエラーメッセージが表示される。変
                数の存在を確認するにはexists()を使う。

isnan({expr})                                           isnan()
                {expr} が NaN の値を持つ浮動小数点数ならば TRUE を返す。
                        echo isnan(0.0 / 0.0)
                        1

                {+float 機能を有効にしてコンパイルしたときのみ有効}

items({dict})                                           items()
                {dict}の全要素のキー・値のペアからなるリストを返す。戻り値の各
                要素はリストであり、キーと値の2個の要素を持つ。戻り値のリスト
                の要素の順序は不定である。

job_getchannel({job})                                    job_getchannel()
                {job}が使用しているチャンネルハンドルを取得する。
                ジョブにチャンネルがないかどうかを確認するには:
                        if string(job_getchannel()) == 'channel fail'

                {Vimが+job機能付きでコンパイルされたときのみ有効}

job_info({job})                                         job_info()
                {job}に関する情報を持つ辞書を返す:
                   "status"     job_status()が返すもの
                   "channel"    job_getchannel()が返すもの
                   "exitval"    "status" が "dead" のときのみ有効
                   "exit_cb"    終了時に呼び出される関数
                   "stoponexit" job-stoponexit

job_setoptions({job}{options})                        job_setoptions()
                {job}のオプションを変更する。サポートされているものは:
                   "stoponexit" job-stoponexit
                   "exit_cb"    job-exit_cb

job_start({command} [, {options}])                      job_start()
                ジョブを開始し、ジョブオブジェクトを返す。system():!cmd
                とは異なり、これはジョブが終了するのを待つことはない。

                {command}は文字列にできる。これはMS-Windowsで最も効果的である。
                Unixでは、それはexecvp()に渡すために空白で区切られたパーツに分
                割される。二重引用符で囲まれた引数には空白を含められる。

                {command}はリストにでき、最初の項目は実行可能ファイルであり、
                残りの項目は引数である。すべての項目は文字列に変換される。これ
                はUnixで最も効果的である。

                MS-Windowsでは、job_start()はGUIアプリケーションを隠す。それ
                を表示したい場合は、:!startを代わりに使用すること。

                コマンドはシェルではなく直接実行され、'shell' オプションは使用
                されない。シェルを使用するには:
        let job = job_start(["/bin/sh", "-c", "echo hello"])
                または:
        let job = job_start('/bin/sh -c "echo hello"')
                これは2つのプロセス、シェルとそれが実行するコマンドを開始する
                ことに注意すること。これを望まない場合は、"exec" シェルコマン
                ドを使用する。

                Unixでは$PATHは、コマンドにスラッシュが含まれていない場合にの
                み実行可能ファイルを検索するために使用される。

                ジョブはVimと同じ端末を使用する。ジョブがstdinを読む場合、ジョ
                ブとVimが入力を奪い合うことになるのでうまく動作しない。問題を
                避けるためにstdinとstdoutをリダイレクトする:
        let job = job_start(['sh', '-c', "myserver </dev/null >/dev/null"])

                返されたジョブオブジェクトを使用して、job_status()でステータ
                スを取得し、job_stop()でジョブを停止することができる。

                {options}は辞書でなければならない。多くのオプション項目を含め
                ることができる。job-options参照。

                {Vimが+job機能付きでコンパイルされたときのみ有効}

job_status({job})                                       job_status() E916
                {job}のステータスをStringで返す:
                        "run"   ジョブが実行中
                        "fail"  ジョブを開始できなかった
                        "dead"  ジョブが死んだか実行後にジョブが停止した

                Unixでは存在しないコマンドは、失敗が検出される前にフォークが発
                生するため、"fail" ではなく "dead" になる。

                exitコールバックが "exit_cb" オプションで設定され、ジョブが
                "dead" と検出された場合、コールバックが呼び出される。

                詳細はjob_info()参照。

                {Vimが+job機能付きでコンパイルされたときのみ有効}

job_stop({job} [, {how}])                                       job_stop()
                {job}を停止する。これはジョブを通知するためにも使用できる。

                {how}が省略されたり、"term" の場合、ジョブは終了する。Unixでは
                SIGTERMが送信される。MS-Windowsでは、ジョブは強制的に終了する
                ("優しい"方法は存在しない)。これはプロセスグループに行くので、
                子供たちも影響を受けるかもしれない。

                UNIXへの影響:
                        "term"   SIGTERM (既定)
                        "hup"    SIGHUP
                        "quit"   SIGQUIT
                        "int"    SIGINT
                        "kill"   SIGKILL (停止するための最も強い方法)
                        number   その番号の信号

                MS-Windowsへの影響:
                        "term"   プロセスを強制終了 (既定)
                        "hup"    CTRL_BREAK
                        "quit"   CTRL_BREAK
                        "int"    CTRL_C
                        "kill"   プロセスを強制終了
                        Others   CTRL_BREAK

                Unixでは、シグナルはプロセスグループに送られる。これは、ジョブ
                が "sh -c command" であるときにシェルとコマンドの両方に影響を
                与えることを意味する。

                結果は数値で、操作が実行できる場合は1、システムでは "how" がサ
                ポートされていない場合は0。
                ジョブが実際に停止したかどうかは、操作が実行された場合でも、
                job_status()でチェックする必要があることに注意すること。
                ジョブのステータスがチェックされていない場合、Vimがジョブが実
                行されていないと判断した場合でも操作が実行される。

                {Vimが+job機能付きでコンパイルされたときのみ有効}

join({list} [, {sep}])                                  join()
                リスト{list}の要素を連結し、1個の文字列にして返す。
                {sep}が指定されたときは、要素の間にそれを挿入する。{sep}が指定
                されなかったときは1個のスペースが使われる。
                Note 末尾には{sep}がつかない。末尾にもつけたければ以下のように
                する:
                        let lines = join(mylist, "\n") . "\n"
                {list}の要素が文字列なら、そのまま使われる。リストと辞書は
                string()を使ったときと同じようにして文字列に変換される。
                この逆を行う関数はsplit()である。

js_decode({string})                                     js_decode()
                json_decode() に似ているが以下が異なる:
                - オブジェクトのキー名はクォートされてなくてもよい。
                - 文字列はシングルクォートでくくることができる。
                - 配列内の(2つのコンマで区切られた)空アイテムが許可され結果と
                  して v:none のアイテムとなる。

js_encode({expr})                                       js_encode()
                json_encode() に似ているが以下が異なる:
                - オブジェクトのキー名がクォートされない
                - 配列の中のアイテム v:none はコンマで区切られた空のアイテムに
                  なる。
                例えば Vim オブジェクト:
                        [1,v:none,{"one":1},v:none]
                は以下にエンコードされ:
                        [1,,{one:1},,]
                json_encode() であれば以下にエンコードされる:
                        [1,null,{"one":1},null]
                このエンコードは JavaScript では妥当である。特に配列内でオプ
                ショナルアイテムを扱う場合には JSON より能率的である。


json_decode({string})                                   json_decode()
                これはJSONフォーマットの文字列を解析し、それと同等のVimの値を
                返す。JSONとVimの値の関係はjson_encode()を参照。
                デコードは寛容である:
                - 配列やオブジェクトの末尾コンマは無視される。
                - 多くの浮動小数点数を認識する。例えば "1." は "1.0" として認
                  識される。
                                                                        E938
                しかし、1つのオブジェクトに重複するキーを含むことはできない。
                結果は必ずVimの型として有効になる:
                - オブジェクトの空のメンバ名は許されない。
                - オブジェクトのメンバ名の重複は許されない。

json_encode({expr})                                     json_encode()
                {expr}をJSONフォーマットの文字列にエンコードし、この文字列を返
                す。
                このエンコード方式の詳細はここに記載されている:
                https://tools.ietf.org/html/rfc7159.html
                Vimの値は以下の通りに変換される:
                   数値                 10進数
                   浮動小数点数         浮動小数点数
                   浮動小数点数 nan     "NaN"
                   浮動小数点数 inf     "Infinity"
                   文字列               ダブルクォートで括られた文字列(null可)
                   Funcref              不可、エラー
                   リスト               配列(null可)
                                        再帰的に使用された場合: []
                   辞書                 オブジェクト(null可)
                                        再帰的に使用された場合: {}
                   v:false              "false"
                   v:true               "true"
                   v:none               "null"
                   v:null               "null"
                NaNとInfinityは値として渡されることに注意すること。これはJSON
                標準には存在しないが、いくつかの実装でそれが可能である。そうで
                ない場合、エラーが発生する。

keys({dict})                                            keys()
                {dict}の全キーからなるリストを返す。リストの順序は不定である。

                                                        len() E701
len({expr})     結果は数値で、引数{expr}の長さ。{expr}が文字列または数値のとき
                はstrlen()と同じようにバイト単位での長さを返す。
                {expr}がリストのときは要素数を返す。
                {expr}が辞書のときは要素数を返す。
                それ以外のときはエラーとなる。

                                                libcall() E364 E368
libcall({libname}{funcname}{argument})
                ランタイムライブラリ{libname}の関数{funcname}を、単一の引数
                {argument}で呼び出す。
                Vimで使うように特別に作ったライブラリの関数を呼ぶために使われ
                る。引数は1個しか指定できないため、普通のライブラリ関数を呼ぶ
                にはかなり制限がある。
                結果には、呼び出した関数から返された文字列が返される。呼び出し
                た関数がNULLを返した場合には、Vimには空文字列 "" が戻される。
                関数の戻り値が数値である場合にはlibcallnr()を使うこと。
                もしも引数が数値ならば、関数にはint型の引数が1つ渡される。引数
                が文字列の場合には、関数にはヌル終端記号を持つ文字列が引数とし
                て渡される。
                restricted-modeの中で呼ぶと失敗する。

                libcall()によってVimを再コンパイルすることなく 'plug-in' と呼
                ばれる独自の拡張を行うことができるようになる。それは (直接) シ
                ステムの関数を呼ぶ、ということではない。システム関数を呼ぶとお
                そらくVimがクラッシュするだろう。

                Win32では、あなたが書いた関数をDLLに置かなければならず、また通
                常のC呼出し規約を使用しなければならない(WindowsのシステムDLLが
                使うPascalではない)。関数は正確に1つのパラメーター、char型ポイ
                ンタもしくはint型を取らなければならず、戻り値としてchar型ポイ
                ンタかNULLを返さなければならない。返されるchar型ポインタは、関
                数終了後も有効なポインタ(例えばDLL内の静的なデータ)を指さなけ
                ればならない。(malloc等で)割り当てられたメモリを保持していた場
                合、それはリークしてしまう。DLL内のスタティックバッファを用い
                る方法は動くかもしれないが、使用済みDLLがメモリから削除される
                と同時に解放されてしまう。

                警告: もしも関数が有効ではないポインタを返すと、Vimはクラッ
                シュしてしまう。関数が数値を返してしまった場合、Vimはそれをポ
                インタとして扱ってしまうので、やはりクラッシュが起こる。
                Win32のシステムでは、{libname}はDLLのファイル名の拡張子 ".DLL"
                を付けてはならない。通常の(パスの通った)場所にDLLがない場合に
                は、フルパスで指定する必要がある。
                Unixでは、独自のプラグインをコンパイルするときはオブジェクト
                コードを位置独立('PIC')としてコンパイルしなければならない。
                {Win32 といくつかの Unix で、+libcall 機能が有効になっている
                ときのみ利用可能}
                例:
                        :echo libcall("libc.so", "getenv", "HOME")
  
                                                        libcallnr()
libcallnr({libname}{funcname}{argument})
                libcall()とほぼ同様だが、文字列でなくintを返す関数に使う。
                {Win32と、+libcall機能が有効になっているUnixでのみ利用可能}
                例:
                        :echo libcallnr("/usr/lib/libc.so", "getpid", "")
                        :call libcallnr("libc.so", "printf", "Hello World!\n")
                        :call libcallnr("libc.so", "sleep", 10)

                                                        line()
line({expr})    結果は数値で、{expr}で与えられた位置のファイル内での行番号。受
                け付けられる位置指定は次の通り:
                    .       カーソルの位置
                    $       現在のバッファの最後の位置
                    'x      マークxの位置(マークが設定されていない場合、0が返
                            る)
                    w0      カレントウィンドウの最上行
                    w$      カレントウィンドウの最下行
                    v       ビジュアルモードでは: ビジュアル選択領域の開始行
                            (カーソルがその端)。ビジュアルモード以外ではカーソ
                            ル位置を返す。すぐに更新される点が '< と違う。
                Note 他のファイルのマークも使える。その場合、戻り値はそのファ
                イルの行番号となる。
                桁番号を取得するにはcol()を使う。両方を取得するには
                getpos()を使う。
                例:
                        line(".")               カーソルの行番号
                        line("'t")              マークtの位置の行番号
                        line("'" . marker)      マークmarkerの位置の行番号
                                                        last-position-jump
                このオートコマンドはファイルを開いた時に、最後に開かれていた時
                の行へ自動的にジャンプするものである。これは '" マークがセット
                されている時にのみ有効である:
        :au BufReadPost * if line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g`\"" | endif

line2byte({lnum})                                       line2byte()
                バッファの先頭から、{lnum}行目までのバイト数を返す。これには現
                在のバッファのオプション 'fileformat' に従った、end-of-line(行
                終端)文字も含まれている。最初の行においては1が返る。バイト数は
                'encoding' に基づく。'fileencoding' は無視される。
                次のようにすることで最終行を含むバイトサイズを獲得することがで
                きる:
                        line2byte(line("$") + 1)
                これはバッファの大きさプラス1になる。もし 'fileencoding' が空
                ならその値はファイルの大きさプラス1に等しい。
                {lnum}が無効であるか、+byte_offset機能がコンパイル時に無効に
                されている場合、-1が返される。
                byte2line()go及び:gotoも参照。

lispindent({lnum})                                      lispindent()
                'lisp' をオンにしたときと同じlisp用のインデント規則に従った場
                合の{lnum}行目のインデント量を返す。
                インデント量はスペースで数えられ、'tabstop' の値は関係ない。
                {lnum}getline()の場合と同様に扱われる。
                {lnum}が無効な値のときや+lispindent機能なしでコンパイルされ
                ているときは-1を返す。

                                                        localtime()
localtime()
                現在の時刻、1970年1月1日からの経過秒数を返す。strftime()
                getftime()も参照。


log({expr})                                             log()
                {expr} の自然対数 (底e) を浮動小数点数 (Float) で返す。
                {expr} は (0, inf] の範囲の浮動小数点数 (Float) か数値
                (Number) でなければならない。
                例:
                        :echo log(10)
                        2.302585
                        :echo log(exp(5))
                        5.0
                {+float 機能を有効にしてコンパイルしたときのみ有効}


log10({expr})                                           log10()
                浮動小数点数 {expr} の 10 を底とする対数を Float で返す。
                {expr} は Float または Number に評価されなければならな
                い。
                例:
                        :echo log10(1000)
                        3.0
                        :echo log10(0.01)
                        -2.0
                {+float 機能つきでコンパイルされたときのみ有効}
                
luaeval({expr}[, {expr}])                                       luaeval()
                Lua の式 {expr} を評価し、その結果を Vim のデータ構造に変換し
                たものを返す。2番目の {expr} は、最初の {expr} の中では _A と
                してアクセスできる追加の引数を保持する。
                文字列はそのまま返される。
                ブーリアンオブジェクトは数値に変換される。
                数値は、vim が +float つきでコンパイルされたときは Float
                値に変換され、そうでなければ数値に変換される。
                vim.eval() で取得される辞書とリストはそのまま返される。
                それ以外のオブジェクトは 0 が返され、エラーにはならない。
                詳細は lua-luaeval を参照。
                {+lua 機能つきでコンパイルされたときのみ有効}

map({expr1}{expr2})                                   map()
                {expr1}はリストListまたは辞書Dictionary
                {expr1}の各要素を、{expr2}を評価した結果で置き換える。
                {expr2}は文字列stringまたは関数参照Funcrefでなければならな
                い。

                {expr2}が文字列の場合、{expr2}の内部ではv:valが現在の要素の
                値を保持している。辞書の場合はv:keyが現在の要素のキーを保持
                している。リストの場合はv:keyが現在の要素のインデックスを保
                持している。
                例:
                        :call map(mylist, '"> " . v:val . " <"')
                これは "mylist" の各要素の前に "> " をつけ、後に " <" をつける。
                Note {expr2}は式を表す文字列である。バックスラッシュを二重に
                しなくても済むようにliteral-stringを使うとよいだろう。ただし
                その場合はシングルクォートを二重にしなければならない。

                {expr2}Funcrefの場合は、2つの引数で呼び出される:
                        1. 現在の要素のキーまたはインデックス。
                        2. 現在の要素の値。
                関数は、その要素の新しい値を返さなければならない。それぞれの値
                を "key-value" に置き換える例:
                        func KeyValue(key, val)
                          return a:key . '-' . a:val
                        endfunc
                        call map(myDict, function('KeyValue'))
                lambda を使えばより短く書ける:
                        call map(myDict, {key, val -> key . '-' . val})
                "val" を使わない場合は省略できる:
                        call map(myDict, {key -> 'item: ' . key})

                この操作はその場で(in-place)行われる。リストや辞書を変更したく
                ない場合は最初にコピーを作ること:
                        :let tlist = map(copy(mylist), ' v:val . "\t"')

                {expr1}のリストまたは辞書に式を適用した結果を返す。{expr2}
                評価している最中にエラーが発生した場合は、{expr1}内のそれ以降
                の要素の処理は行われない。{expr2}が関数参照の場合、関数が
                "abort" フラグつきで定義されていない限り、関数内のエラーは無視
                される。


maparg({name}[, {mode} [, {abbr} [, {dict}]]])                  maparg()
                {dict}が省略されたかゼロのとき: モード{mode}におけるキーマップ
                {name}のrhsを返す。結果の文字列内の特殊文字は、":map" コマンド
                でリスト表示した時のように変換される。
                
                {name}というキーマップが存在しない場合、空文字列が返される。
                
                {name}には ":map" コマンドで使用可能な、特殊なキー名が指定でき
                る。
                
                {mode}には次の文字が使用可能:
                        "n"     ノーマル
                        "v"     ビジュアル (選択含む)
                        "o"     オペレータ待機 (Operator-pending)
                        "i"     挿入
                        "c"     コマンドライン
                        "s"     選択
                        "x"     ビジュアル
                        "l"     langmap language-mapping
                        ""      ノーマル、ビジュアル、及びオペレータ待機
                {mode}が省略された場合、"" が使用される。

                {abbr}が指定され、TRUEの場合はマッピングでなく短縮入力を対象
                とする。

                {dict} にTRUEが指定されたときはマッピングのすべての情報を含
                んだ辞書が返る:
                  "lhs"      マッピングの {lhs}
                  "rhs"      マッピングの {rhs} (入力されたまま)
                  "silent"   :map-silent マッピングなら 1。そうでなければ0。
                  "noremap"  マッピングの {rhs} が再マップ可能なら 1。
                  "expr"     式マッピング (:map-<expr>) なら 1。
                  "buffer"   バッファローカルマッピング (:map-local) なら1。
                  "mode"     マッピングが定義されているモード。上述のモードに
                             加え、次の文字が使用される:
                             " "     ノーマル、ビジュアル、オペレータ待機
                             "!"     挿入、コマンドラインモード (mapmode-ic)
                  "sid"      <sid> マッピングで使用されるスクリプトローカルID
                             (<SID>)。
                  "nowait"   他の長いマッピングを待たない。(:map-<nowait>)。

                まずカレントバッファにローカルなマッピングを探し、次のグローバ
                ルマッピングを探す。
                この関数を使うと、あるキーに対して既にマップがされているとき、
                その動作を行いつつ、再マップすることができる。概要:
                        exe 'nnoremap <Tab> ==' . maparg('<Tab>', 'n')

mapcheck({name}[, {mode} [, {abbr}]])                   mapcheck()
                モード{mode}におけるキーマップ{name}が存在するかチェックする。
                {name}に指定できる特殊文字はmaparg()を参照。
                {abbr}が指定され、TRUEの場合はマッピングでなく短縮入力を対象
                とする。
                マッピングが{name}で始まるとき、またはマッピングが{name}のはじ
                めに等しいときマッチすると見なされる。

                        マッチするか    "a"     "ab"    "abc"
                   mapcheck("a")        yes     yes      yes
                   mapcheck("abc")      yes     yes      yes
                   mapcheck("ax")       yes     no       no
                   mapcheck("b")        no      no       no

                maparg()との違いは、mapcheck()は{name}にマッチするマップを見つ
                けるが、maparg()はぴったり{name}に一致するマッピングのみを見つ
                ける。
                {name}にマッチするキーマップが存在しない時には、空文字列が返さ
                れる。結果が一つならばマップされたrhsが返される。複数見つかっ
                た場合には、それらのうちどれか一つのrhsが返される。
                まずカレントバッファにローカルなマッピングを探し、次のグローバ
                ルマッピングを探す。
                この関数はマッピングが曖昧にならないかチェックするために使うこ
                とができる。例:
        :if mapcheck("_vv") == ""
        :   map _vv :set guifont=7x13<CR>
        :endif
                これは、"_vv" というマッピングが "_v" とか "_vvv" といったマッ
                ピングと衝突しないように事前にチェックしている。

match({expr}{pat}[, {start}[, {count}]])                      match()
                {expr}がリストの場合は、{pat}にマッチする最初の要素のインデッ
                クスを返す。各要素は文字列として扱われる。リストと辞書はechoし
                たときと同じように文字列表現に変換される。
                それ以外の場合は、{expr}は文字列として扱われる。{expr}の中で
                {pat}にマッチするインデックス(バイト単位のオフセット)を表す数
                値を返す。
                最初の文字またはリストの最初の要素にマッチしたときは0を返す。
                マッチがないときは-1を返す。
                サブマッチを取得するには matchlist() を参照。
                例:
                        :echo match("testing", "ing")   " 結果は 4
                        :echo match([1, 'x'], '\a')     " 結果は 1
                {pat}の扱われ方についてはstring-matchを参照。
                                                                strpbrk()
                strpbrk()に相当する関数はVimに存在しない。しかし同じことを次の
                ようにしてできる:
                        :let sepidx = match(line, '[.,;: \t]')
                                                                strcasestr()
                strcasestr()に相当する関数はVimに存在しない。しかし正規表現に
                "\c" をつければ大文字・小文字の違いを無視できる:
                        :let idx = match(haystack, '\cneedle')

                {start}が指定されたときは、文字列のバイトインデックス{start}
                位置、またはリストの{start}の要素から検索を始める。
                その場合も戻り値は最初の文字/要素から数えたインデックスである
                ことに注意。例:
                        :echo match("testing", "ing", 2)
                の結果は "4"。
                        :echo match("testing", "ing", 4)
                の結果は "4"。
                        :echo match("testing", "t", 2)
                の結果は "3"。
                文字列の場合、{start} > 0のときは、その文字列が{start}バイト後
                から始まるかのように扱われる。そのため、"^" は{start}の位置に
                マッチする。ただし{count}が指定されたときは、{start}より前にお
                けるマッチを無視しているかのように振る舞う(これは後方互換性を
                保つのを少々複雑にしている)。
                文字列の場合、{start} < 0のときは{start}に0をセットする。リス
                トの場合は、末尾からインデックスを数えるという意味になる。
                {start}が範囲外の場合(文字列で{start} > strlen({expr})となった
                場合、リストで{start} > len({expr})となった場合)は-1を返す。

                {count}が指定されたときは{count}番目のマッチ位置を返す。文字列
                でマッチが見つかったとき、次のマッチングは1文字先から行われる。
                よって次の例は1を返す:
                        echo match("testing", "..", 0, 2)
                リストの場合は次の要素から検索を続ける。
                Note {count}を指定すると、{start}の扱い方が変わってしまう。
                前の段落を参照。

                受け付ける正規表現についてはpatternを参照。
                オプション 'ignorecase' により、大文字・小文字を区別するかどう
                かを設定できる。'smartcase' は適用されない。マッチングは常に
                'magic' をオン、'cpoptions' を空にした状態で行われる。

                                        matchadd() E798 E799 E801
matchadd({group}{pattern}[, {priority}[, {id}[, {dict}]]])
                カレントウィンドウで強調表示するパターンを定義する。このパター
                ンのことを「マッチ」と呼ぶ。構文グループ {group}で強調する。戻
                り値は、マッチを識別する ID である。matchdelete()でこの ID
                を指定してマッチを削除することができる。
                パターンは大文字小文字を区別し、magic (/magic) として解釈さ
                れる ({pattern} の中で明示的に変更しない限り)。オプションの
                'magic''smartcase''ignorecase' は使用されない。
                Concealは特別であり、マッチを隠す作用がある。

                省略可能な引数 {priority} はマッチの優先度を指定する。優先度が
                高いマッチは、より低いマッチの強調を上書きする。優先度は整数で
                指定する(負の数も可能)。{priority} が指定されない場合は既定の
                優先度 10 となる。'hlsearch' の優先度はゼロで、したがってゼロ
                より大きい優先度のマッチはすべてそれを上書きする。構文ハイライ
                ト('syntax' を参照)は独立したメカニズムであり、優先度がいくつ
                であろうとマッチは構文ハイライトより優先する。

                {id} は特定のマッチ ID を返すことを要求する。指定された ID が
                すでに使われていたら、エラーメッセージが表示され、そのマッチは
                登録されない。ID は正の整数を指定する(ゼロは除く)。ID 1, 2, 3
                は :match:2match:3match 用に予約されている。{id} が
                指定されないか -1 のときは、matchadd() が自動的に空いている
                ID を取得する。

                省略可能な引数 {dict} はより一層カスタマイズ可能な値を許す。
                現在、これはhl-Concealでハイライトされたマッチをconceal文字で
                表示されるのを明示するために使われる。
                この辞書は下記のメンバを持つことができる:

                        conceal     マッチ(hl-Concealのためだけにハイライトさ
                                    れたマッチ、:syn-ccharを参照)の代わりに
                                    表示する特別な文字

                コマンド :match と異なり、マッチの個数に上限はない。

                例:
                        :highlight MyGroup ctermbg=green guibg=green
                        :let m = matchadd("MyGroup", "TODO")
                このパターンを削除するには:
                        :call matchdelete(m)

                matchadd() と :match で定義したマッチのリストは
                getmatches() で取得できる。全てのマッチを削除するのは
                clearmatches() 一発でできる。

                                                        matchaddpos()
matchaddpos({group}{pos}[, {priority}[, {id}[, {dict}]]])
                matchadd() と同じだが、パターンを指定するのではなく、位置の
                リスト {pos} を指定する。このコマンドは正規表現を扱う必要もな
                く、画面更新のためにバッファ行の境界を設定するため、
                matchadd() よりも速い。これは、例えば括弧の対応を強調表示す
                るような、マッチの追加と削除を高速に実行したい状況を想定してい
                る。

                リスト {pos} は以下のいずれかの値を要素として持つことができる:
                - 数値。指定した行全体が強調表示される。最初の行の行番号は 1
                  である。
                - 数値を 1 つ持ったリスト。例 [23]。指定した行全体が強調表示さ
                  れる。
                - 数値を 2 つ持ったリスト。例 [23, 11]。最初の数値は行番号、2
                  番目の数値は列番号である (最初の列は 1 である。値は col()
                  の戻り値と同じようにバイト単位である)。指定した位置の文字が
                  強調表示される。
                - 数値を 3 つ持ったリスト。例 [23, 11, 3]。数値 2 つの場合と同
                  じだが、3 つ目に強調表示する文字の長さ (バイト単位) を指定す
                  る。
                
                指定できる位置は最大で 8 個である。

                例:
                        :highlight MyGroup ctermbg=green guibg=green
                        :let m = matchaddpos("MyGroup", [[23, 24], 34])
                パターンの削除:
                        :call matchdelete(m)

                matchaddpos() で追加されたマッチは getmatches() で取得する
                際には "pos1"、"pos2"、... という項目を持つ。それぞれの値は
                {pos} で指定された値である。
                これらのマッチは setmatches() で設定することはできない。ただ
                し、clearmatches() で削除することはできる。

matcharg({nr})                                                  matcharg()
                :match:2match:3matchによって設定されているマッチパター
                ンの情報を返す。{nr}が1のときは:matchの情報、2のときは
                :2matchの情報、3のときは:3matchの情報を返す。
                戻り値は次の2個の要素を持つリストである:
                        引数で指定したハイライトグループ名
                        引数で指定した検索パターン
                {nr}が1、2、3のどれでもないときは空リストを返す。
                マッチパターンがセットされていないときは['', '']を返す。
                :match を保存し、復元するのに便利である。
                :match を使った強調は 3 個までに限られている。
                matchadd() にはこの制限はない。

matchdelete({id})                              matchdelete() E802 E803
                matchadd() または :match で定義したマッチの中で ID が {id}
                であるものを削除する。成功したときは 0、失敗したときは
                -1 を返す。matchadd() の例を参照。すべてのマッチを削除するの
                は clearmatches() 一発でできる。

matchend({expr}{pat}[, {start}[, {count}]])                   matchend()
                match()と同じだが、返されるのはマッチした部分文字列の終了後の
                インデックスである。例:
                        :echo matchend("testing", "ing")
                結果は "7"。
                                                        strspn() strcspn()
                Vimにはstrspn()やstrcspn()に相当する関数はないが、matchend()を
                使えば同じことができる:
                        :let span = matchend(line, '[a-zA-Z]')
                        :let span = matchend(line, '[^a-zA-Z]')
                ただしマッチがないときには-1を返すところが異なる。

                {start}match()の場合と同じ意味を持つ。
                        :echo matchend("testing", "ing", 2)
                結果は "7"。
                        :echo matchend("testing", "ing", 5)
                結果は "-1"。
                {expr}がリストの場合、戻り値は match() と等しくなる。

matchlist({expr}{pat}[, {start}[, {count}]])                  matchlist()
                match() と同じだがリストを返す。リストの最初の要素は、
                matchstr()が返すのと同じマッチした文字列。それ以降の要素は
                :substituteにおける "\1"、"\2" のようなサブマッチである。\1
                から\9までの間で、指定されなかったものは空文字列となる。例:
                        echo matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)')
                結果は['acd', 'a', '', 'c', 'd', '', '', '', '', '']となる。
                マッチしなかったときは空リストを返す。

matchstr({expr}{pat}[, {start}[, {count}]])                   matchstr()
                match() と同じだが、マッチした文字列を返す。例:
                        :echo matchstr("testing", "ing")
                結果は "ing"。
                マッチしなかったときは "" を返す。
                {start}の意味は match() の場合と同じ。
                        :echo matchstr("testing", "ing", 2)
                結果は "ing"。
                        :echo matchstr("testing", "ing", 5)
                結果は ""。
                {expr}がリストのときはマッチした要素を返す。
                その要素の型は変換されないため、必ずしも文字列であるとは限らな
                い。

matchstrpos({expr}{pat}[, {start}[, {count}]])                matchstrpos()
                matchstr() と同じだがマッチした文字列とマッチした開始位置と
                終了位置を返す。例:
                        :echo matchstrpos("testing", "ing")
                結果は ["ing", 4, 7] である。
                マッチが無い場合は ["", -1, -1] が返る。
                {start} が指定されている場合は match() と同じ意味になる。
                        :echo matchstrpos("testing", "ing", 2)
                結果は ["ing", 4, 7] である。
                        :echo matchstrpos("testing", "ing", 5)
                結果は ["", -1, -1] である。
                {expr} が List の場合、マッチしたアイテム、{pat} でマッチし
                た最初のインデックス、マッチの開始位置と終了位置が返る。
                        :echo matchstrpos([1, '__x'], '\a')
                結果は ["x", 1, 2, 3] である。
                型は変更されない。必ずしも文字列である必要はない。

                                                        max()
max({expr})     {expr}の全要素の値の最大値を返す。
                {expr}はリストか辞書である。辞書の場合、辞書に含まれるすべての
                値の最大値を返す。
                {expr}がリストでも辞書でもなかったり、要素のどれかが数値に変換
                できない場合はエラーとなる。
                空のリストまたは辞書の場合は0を返す。

                                                        min()
min({expr})     {expr}の全要素の値の最小値を返す。
                {expr}はリストか辞書である。辞書の場合、辞書に含まれるすべての
                値の最小値を返す。
                {expr}がリストでも辞書でもなかったり、要素のどれかが数値に変換
                できない場合はエラーとなる。
                空のリストまたは辞書の場合は0を返す。

                                                        mkdir() E739
mkdir({name} [, {path} [, {prot}]])
                ディレクトリ{name}を作成する。
                {path}が "p" のときは必要に応じて途中のディレクトリも作成され
                る。そうでないときは "" にすること。
                {prot}は作成するディレクトリの保護ビット。デフォルトは0755
                (rwxr-xr-x: 所有者は読み書き可能、他の人は読み込み可能)。
                他の人が読み込めないようにするには0700とすること。{prot} は
                {name} の最後の部分にのみ適用される。なので、/tmp/foo/bar
                を作成すると /tmp/foo は 0755 で作成される。
                例:
                        :call mkdir($HOME . "/tmp/foo/bar", "p", 0700)
                sandboxの中ではこの関数は使用できない。
                システムによっては利用できない場合がある。これを確認するには次
                のようにする:
                        :if exists("*mkdir")

                                                        mode()
mode([expr])            現在のモードを示す文字列を返す。
                        [expr] に 0 でない数値か空でない文字列(non-zero-arg)
                        を指定した場合、フルモードが返される。それ以外の場合は
                        最初の一文字だけが返される。

                        n       ノーマル
                        no      オペレータ待機
                        v       文字単位ビジュアル
                        V       行単位ビジュアル
                        CTRL-V  矩形ビジュアル
                        s       文字単位選択
                        S       行単位選択
                        CTRL-S  矩形選択
                        i       挿入
                        ic      挿入モード補完 compl-generic
                        ix      挿入モード i_CTRL-X 補完
                        R       置換 R
                        Rc      置換モード補完 compl-generic
                        Rv      仮想置換 gR
                        Rx      置換モード i_CTRL-X 補完
                        c       コマンドライン編集
                        cv      Vim Ex モード gQ
                        ce      ノーマル Ex モード Q
                        r       Hit-enter プロンプト
                        rm      -- more -- プロンプト
                        r?      ある種の :confirm 問い合わせ
                        !       シェルまたは外部コマンド実行中
                これらはオプション 'statusline' の中や、remote_expr() といっ
                しょに使うと便利である。他のほとんどの場所では "c" または "n"
                しか返さない。
                visualmode() も参照。

mzeval({expr})                                                  mzeval()
                MzScheme の式 {expr} を評価してその結果を Vim の変数に変換した
                結果を返す。
                数値と文字列はそのまま返る。
                ペア (リストと不適切なリスト (improper list) を含む) とベクタ
                は Vim のリスト (Lists) に変換される。
                ハッシュテーブルは Vim の辞書 (Dictionary) に変換され、その
                キーは文字列に変換される。
                その他のすべての型は display 関数を使って文字列に変換される。
                例:
                    :mz (define l (list 1 2 3))
                    :mz (define h (make-hash)) (hash-set! h "list" l)
                    :echo mzeval("l")
                    :echo mzeval("h")

                {+mzscheme 機能を有効にしてコンパイルしたときのみ有効}

nextnonblank({lnum})                                    nextnonblank()
                {lnum}行以降({lnum}行を含む)の最初の非空行の行番号を返す。
                例:
                        if getline(nextnonblank(1)) =~ "Java"
                {lnum}が無効なときや、それ以降に非空行がないときは0を返す。
                prevnonblank()も参照。

nr2char({expr}[, {utf8}])                               nr2char()
                コード{expr}で表される1文字からなる文字列を返す。例:
                        nr2char(64)             "@"を返す
                        nr2char(32)             " "を返す
                {utf8} を省略、またはゼロを指定すると、現在の 'encoding' が適
                用される。"utf-8" の場合の例:
                        nr2char(300)            短音記号つきのIを返す
                {utf8} に 1 を指定すると、常に utf-8 文字が返る。
                Note Vim内部では、ファイル中のNUL文字を改行文字(0x0A)に変換し
                て保持している。そのため、nr2char(10)とすればNUL文字を指定でき
                る。nr2char(0)は真のNUL文字(文字列の終端)となるので、空文字列
                を返す。

or({expr}{expr})                                      or()
                二つの引数のビット論理和。引数は数値に変換される。リスト、辞
                書、浮動小数点数を指定するとエラーになる。
                例:
                        :let bits = or(bits, 0x80)


pathshorten({expr})                                     pathshorten()
                パス{expr}におけるディレクトリ名を短縮して返す。拡張子、ファイ
                ル名はそのまま保たれる。パスのその他の構成要素は1文字に縮めら
                れる。1文字目の '~' と '.' はそのまま保たれる。例:
                        :echo pathshorten('~/.vim/autoload/myfile.vim')
                        ~/.v/a/myfile.vim
                パスが実際に存在するかどうかは関係ない。

perleval({expr})                                        perleval()
                Perl の式 {expr} をスカラーコンテキストで評価して、結果をVimの
                データ形式にして返す。
                もし値が変換できない場合、Perlにおける文字列として返される。
                Note: もし配列かハッシュが必要ならば、{expr}ではそれらへの参照
                を返す必要がある。
                例:
                        :echo perleval('[1 .. 4]')
                        [1, 2, 3, 4]
                {+perl 機能付きでコンパイルされたときのみ利用可能}

pow({x}{y})                                           pow()
                {x} の {y} 乗を Float で返す。{x} と {y} は Float または
                Number に評価されなければならない。
                例:
                        :echo pow(3, 3)
                        27.0
                        :echo pow(2, 16)
                        65536.0
                        :echo pow(32, 0.20)
                        2.0
                {+float 機能つきでコンパイルされたときのみ有効}
                
prevnonblank({lnum})                                    prevnonblank()
                {lnum}行以前({lnum}行を含む)の最初の非空行の行番号を返す。
                例:
                        let ind = indent(prevnonblank(v:lnum - 1))
                {lnum}が無効なときや、それ以降に非空行がないときは0を返す。
                nextnonblank()も参照。


printf({fmt}{expr1} ...)                              printf()
                {fmt}にしたがって組み立てた文字列を返す。{fmt}中の "%" 変換指
                示子は、対応する引数の値で置き換えられる。例:
                        printf("%4d: E%d %.30s", lnum, errno, msg)
                結果は次のような形になる:
                        "  99: E42 asdfasdfasdfasdfasdfasdfasdfas"

                よく使われる変換指示子は次の通り:
                  %s    文字列
                  %6S   6表示幅で右揃えした文字列
                  %6s   6バイトで右揃えした文字列
                  %.9s  9バイトに切り詰めた文字列
                  %c    1バイト
                  %d    10進数値
                  %5d   スペースで埋めて5文字にした10進数値
                  %x    16進数値
                  %04x  0で埋めて少なくとも4文字にした16進数値
                  %X    16進数値(大文字)
                  %o    8進数値
                  %08b  最低8文字の0埋めされた2進数
                  %f    浮動小数点数。12.23, inf, -inf, nan
                  %F    浮動小数点数。12.23, INF, -INF, NAN
                  %e    浮動小数点数。1.23e3, inf, -inf, nan
                  %E    浮動小数点数。1.23E3, INF, -INF, NAN
                  %g    浮動小数点数。値によって %f または %e となる
                  %G    浮動小数点数。値によって %F または %E となる
                  %%    文字 % そのもの

                変換指示子は '%' で始まり、変換文字で終わる。それ以外の全ての
                文字はそのままになる。

                "%" は変換指示子の開始を意味する。以下の順序で引数を指定できる:

                        %  [flags]  [field-width]  [.precision]  type

                フラグ
                        0個以上の以下のフラグを指定できる

                    #         値を「代替形式」に変換する。変換指示子c, d, sに
                              対してはこのオプションは効果を持たない。変換指示
                              子oに対しては数値の精度を上げ、出力文字列の最初
                              の文字が0になる。(明示的な精度0で値0が表示される
                              ときを除く)
                              変換指示子bとBに対しては、値が0でない場合、文字
                              列 "0b" (変換子Bの場合は "0B")を前につける。
                              変換指示子xとXに対しては、値が0でない場合、文字
                              列 "0x" (変換子Xの場合は "0X")を前につける。

                    0 (zero)  ゼロパディングする。全ての変換に対し、変換された
                              値の左側を空白でなく0で埋める。数値変換(d, b, B,
                              o, x, X)に対して精度が指定されている場合はフラグ
                              0は無視される。

                    -         負のフィールド幅を示す。変換値がフィールド境界に
                              左揃えされる。変換値の左に空白や0がつくのではな
                              く、変換値の右に空白がつく。
                              -と0を両方指定した場合は-が有効になる。

                    ' ' (space)  空白。符号付き変換(d)で作成される正の数値の前
                              に空白が残る。

                    +         +文字。符号付き変換で作成される数値の前に常に符
                              号を付ける。+と' '(space)を両方指定した場合は+が
                              有効になる。

                フィールド幅
                        10進数文字列(省略可)。最低フィールド幅を指定する。変換
                        値のバイト数がこのフィールド幅より少ない場合、左に空白
                        がついて(左揃えフラグを指定した場合は右に空白がついて)
                        フィールドの幅に合わせられる。

                .精度
                        ピリオド '.' の次に数字文字列がつづく形式の精度(省略
                        可)。数字文字列を省略した場合、精度は0になる。d, o, x,
                        X変換における最低桁数を指定する。また、s変換における最
                        大バイト数を指定する。
                        浮動小数点数の場合は小数点以下の桁数。

                型
                        変換の型を指定する1文字。下記を参照。

                フィールド幅と精度には、数字文字列の代わりにアスタリスク '*'
                を指定できる。その場合、対応する数値の引数がフィールド幅または
                精度となる。負のフィールド幅を指定すると、絶対値がフィールド幅
                となり、左揃えフラグがオンになる。負の精度を指定すると、完全に
                無視される。例:
                        :echo printf("%d: %.*s", nr, width, line)
                この例は、テキスト "line" の長さを "width" バイトに制限する。

                変換指示子の意味は以下の通り: 

                                printf-d printf-b printf-B printf-o
                                printf-x printf-X
                dbBoxX  数値の引数を符号付き10進数(d)、符号なし2進数(bまたは
                        B)、符号なし8進数(o)、符号なし16進数(xまたはX)の書式に
                        変換する。xの場合は "abcdef" と小文字を使い、Xの場合は
                        "ABCDEF" と大文字を使う。
                        精度が指定されていれば出力する最小桁数を意味する。変換
                        された値を出力するのにそれ以下しか必要としない場合は、
                        左側にゼロを加えて埋める。
                        フィールド幅が存在しない場合や小さすぎる場合でも、数値
                        の幅を切り詰めることは決してない。変換結果がフィールド
                        幅より多くの桁を必要とする場合は、十分な幅に広げられる。
                        モディファイア 'h' は引数が16ビット引数である事を示す。
                        モディファイア 'l' は引数が32ビット引数をある事を示す。
                        モディファイア 'L' は引数が64ビット引数をある事を示す。
                        一般的にモディファイアは便利ではない。引数から型が分か
                        る時には無視されてしまう。

                i       d のエイリアス
                D       ld のエイリアス
                U       lu のエイリアス
                O       lo のエイリアス

                                                        printf-c
                c       引数の数値を1バイトに変換し、結果の文字列を書き出す。

                                                        printf-s
                s       引数の文字列を出力する。精度を指定した場合、その数値以
                        下のバイト数のみを書き出す。
                        引数が文字列型ではない場合、":echo" と同じ形式のテキス
                        トに自動的に変換される。
                                                        printf-S
                S       引数の文字列を出力する。精度を指定した場合、その数値以
                        下の表示幅のみを書き出す。+multi_byte 機能がない場合
                        は 's' と同じ動作になる。

                                                        printf-f E807
                f F     Float の引数を 123.456 の形式の文字列に変換する。精度
                        は小数点以下の桁数を指定する。精度が 0 のときは小数点
                        以下は省略される。精度を指定しないときは 6 桁となる。
                        とてつもなく大きい数(範囲外またはゼロによる除算)のとき
                        は %f の場合 "inf" または "-inf" となる (%F の場合は
                        "INF" または "-INF")。"0.0 / 0.0" は %f の場合 "nan"
                        になる (%F の場合は "NAN")。
                        例:
                                echo printf("%.2f", 12.115)
                                12.12
                        丸めはシステムのライブラリに依存する。心配なときは
                        round() を使うこと。

                                                        printf-e printf-E
                e E     Float の引数を 1.234e+03 という形式('E' のときは
                        1.234E+03)の文字列に変換する。精度は 'f' の場合と同じ
                        く小数点以下の桁数を指定する。

                                                        printf-g printf-G
                g G     0.001(を含む)から10000000.0(を除く)の間の場合は 'f' の
                        形式で変換し、この間にない場合は 'g' は 'e'、'G' は 'E'
                        の形式によって変換する。精度が指定されないときは余分な
                        ゼロ(小数点の直後のゼロ以外)と '+' 記号は省かれる。よっ
                        て 10000000.0 は 1.0e7 になる。

                                                        printf-%
                %       単一の '%' を書き出す。引数は変換しない。完全な変換指
                        定は "%%" となる。

                数値の引数を受け取る変換指示子には文字列を与えることもできる。
                変換は自動的に行われる。
                浮動小数点数または文字列の引数を受け取る変換指示子には、数値を
                与えることもできる。変換は自動的に行われる。
                それ以外の型の引数を与えるとエラーメッセージが表示される。

                                                        E766 E767
      &nb