GitHub/vim
1
0
Fork 0
mirror of https://github.com/vim/vim synced 2025-07-16 01:01:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

updated for version 7.0029

Browse Source
This commit is contained in:
Bram Moolenaar
2005-01-03 21:02:03 +00:00
parent f9980f116b
commit d7ee7ce231
6 changed files with 271 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

299
runtime/doc/eval.txt
View File

@ -1,4 +1,4 @@
*eval.txt* For Vim version 7.0aa. Last change: 2004 Dec 10
*eval.txt* For Vim version 7.0aa. Last change: 2005 Jan 03
VIM REFERENCE MANUAL by Bram Moolenaar
@ -29,12 +29,15 @@ last chapter below.
==============================================================================
1. Variables *variables*
There are two types of variables:
There are three types of variables:
Number a 32 bit signed number.
String a NUL terminated string of 8-bit unsigned characters.
Number a 32 bit signed number
String a NUL terminated string of 8-bit unsigned characters (bytes)
Funcref a reference to a function |Funcref|
List an ordered sequence of items |List|
These are converted automatically, depending on how they are used.
The Number and String types are converted automatically, depending on how they
are used.
Conversion from a Number to a String is by making the ASCII representation of
the Number. Examples: >
@ -64,6 +67,63 @@ Note that in the command >
use strlen(): >
:if strlen("foo")
Function references ~
*Funcref*
A Funcref variable is obtained with the |function()| function. It can be used
in an expression to invoke the function it refers to by using it in the place
of a function name, before the parenthesis around the arguments. Example: >
:let Fn = function("MyFunc")
:echo Fn()
Note that this doesn't work with |:call|, because its argument is not an
expression.
The name of the referenced function can be obtained with |string()|. A
Funcref variable must start with a capital, "s:", "w:" or "b:".
Lists ~
*List*
A List is an ordered sequence of items. An item can be of any type. Items
can be accessed by their index number. Items can be added and removed at any
position in the sequence.
A List is created with a comma separated list of items in square brackets.
Example: >
:let mylist = [1, 'two', 3, "four"]
An item can be any expression. Using a List for an item creates a
two-dimensional List: >
:let mylist = [[11, 12], [21, 22], [31, 32]]
An extra comma after the last item is ignored.
An item in the List can be accessed by putting the index in square brackets
after the List: >
:let item = mylist[2] " get the third item: 3
<
*list-index*
Indexes are zero-based, thus the first item has index zero. A negative index
is counted from the end. Index -1 refers to the last item in the List, -2 to
the last but one item, etc. >
:let last = mylist[-1] " get the last item: "four"
A part of the List can be obtained by specifying the first and last index,
separated by a colon in square brackets: >
:let smalllist = mylist[2:-1] " get List [3, "four"]
Omitting the first index is similar to zero. Omitting the last index is
similar to -1. The difference is that there is no error if the items are not
available. >
:let endlist = [2:] " from item 2 to the end: [3, "four"]
:let shortlist = [1:1] " List with one item: ['two']
:let otherlist = [:] " make a copy
More about variables ~
If you need to know the type of a variable or expression, use the |type()|
function.
@ -122,11 +182,13 @@ Expression syntax summary, from least to most significant:
+ expr7 unary plus
expr8
|expr8| expr9[expr1] index in String
|expr8| expr9[expr1] byte of a String or item of a List
expr9[expr1 : expr2] substring of a String or sublist of a List
|expr9| number number constant
"string" string constant, backslash is special
'string' string constant
[expr1, ...] List
&option option value
(expr1) nested expression
variable internal variable
@ -134,6 +196,7 @@ Expression syntax summary, from least to most significant:
$VAR environment variable
@r contents of register 'r'
function(expr1, ...) function call
Funcref(expr1, ...) function call with Funcref variable
func{ti}on(expr1, ...) function call with curly braces
@ -301,19 +364,59 @@ These three can be repeated and mixed. Examples:
expr8 *expr8*
-----
expr9[expr1] index in String *expr-[]* *E111*
expr9[expr1] item of String or List *expr-[]* *E111*
This results in a String that contains the expr1'th single byte from expr9.
expr9 is used as a String, expr1 as a Number. Note that this doesn't work for
multi-byte encodings.
If expr9 is a Number or String this results in a String that contains the
expr1'th single byte from expr9. expr9 is used as a String, expr1 as a
Number. Note that this doesn't recognize multi-byte encodings.
Note that index zero gives the first character. This is like it works in C.
Careful: text column numbers start with one! Example, to get the character
under the cursor: >
Index zero gives the first character. This is like it works in C. Careful:
text column numbers start with one! Example, to get the character under the
cursor: >
:let c = getline(line("."))[col(".") - 1]
If the length of the String is less than the index, the result is an empty
String.
String. A negative index always results in an empty string (reason: backwards
compatibility). Use [-1:] to get the last byte.
If expr9 is a List then it results the item at index expr1. See |list-index|
for possible index values. If the index is out of range this results in an
error. Example: >
:let item = mylist[-1] " get last item
Generally, if a List index is equal to or higher than the length of the List,
or more negative than the length of the List, this results in an error.
expr9[expr1a : expr1b] substring or sublist *expr-[:]*
If expr9 is a Number or String this results in the substring with the bytes
from expr1a to and including expr1b. expr9 is used as a String, expr1a and
expr1b are used as a Number. Note that this doesn't recognize multi-byte
encodings.
If expr1a is omitted zero is used. If expr1b is omitted the length of the
string minus one is used.
A negative number can be used to measure from the end of the string. -1 is
the last character, -2 the last but one, etc.
If an index goes out of range for the string characters are omitted. If
expr1b is smaller than expr1a the result is an empty string.
Examples: >
:let c = name[-1:] " last byte of a string
:let c = name[-2:-2] " last but one byte of a string
:let s = line(".")[4:] " from the fifth byte to the end
:let s = s[:-3] " remove last two bytes
If expr9 is a List this results in a new List with the items indicated by the
indexes expr1a and expr1b. This works like with a String, as explained just
above, except that indexes out of range cause an error. Examples: >
:let l = mylist[:3] " first four items
:let l = mylist[4:4] " List with one item
:let l = mylist[:] " shallow copy of a List
Using expr9[expr1] or expr9[expr1a : expr1b] on a Funcref results in an error.
*expr9*
number
@ -806,50 +909,54 @@ See |function-list| for a list grouped by what the function is used for.
USAGE RESULT DESCRIPTION ~
append( {lnum}, {string}) Number append {string} below line {lnum}
append( {lnum}, {string}) Number append {string} below line {lnum}
append( {list}, {item}) List append {item} to List {list}
argc() Number number of files in the argument list
argidx() Number current index in the argument list
argidx() Number current index in the argument list
argv( {nr}) String {nr} entry of the argument list
browse( {save}, {title}, {initdir}, {default})
String put up a file requester
browsedir( {title}, {initdir}) String put up a directory requester
bufexists( {expr}) Number TRUE if buffer {expr} exists
buflisted( {expr}) Number TRUE if buffer {expr} is listed
bufloaded( {expr}) Number TRUE if buffer {expr} is loaded
buflisted( {expr}) Number TRUE if buffer {expr} is listed
bufloaded( {expr}) Number TRUE if buffer {expr} is loaded
bufname( {expr}) String Name of the buffer {expr}
bufnr( {expr}) Number Number of the buffer {expr}
bufwinnr( {expr}) Number window number of buffer {expr}
byte2line( {byte}) Number line number at byte count {byte}
byteidx( {expr}, {nr}) Number byte index of {nr}'th char in {expr}
byteidx( {expr}, {nr}) Number byte index of {nr}'th char in {expr}
char2nr( {expr}) Number ASCII value of first char in {expr}
cindent( {lnum}) Number C indent for line {lnum}
cindent( {lnum}) Number C indent for line {lnum}
col( {expr}) Number column nr of cursor or mark
confirm( {msg} [, {choices} [, {default} [, {type}]]])
Number number of choice picked by user
copy( {expr}) any make a shallow copy of {expr}
cscope_connection( [{num} , {dbpath} [, {prepend}]])
Number checks existence of cscope connection
cursor( {lnum}, {col}) Number position cursor at {lnum}, {col}
cursor( {lnum}, {col}) Number position cursor at {lnum}, {col}
deepcopy( {expr}) any make a full copy of {expr}
delete( {fname}) Number delete file {fname}
did_filetype() Number TRUE if FileType autocommand event used
diff_filler( {lnum}) Number diff filler lines about {lnum}
diff_hlID( {lnum}, {col}) Number diff highlighting at {lnum}/{col}
diff_filler( {lnum}) Number diff filler lines about {lnum}
diff_hlID( {lnum}, {col}) Number diff highlighting at {lnum}/{col}
escape( {string}, {chars}) String escape {chars} in {string} with '\'
eventhandler( ) Number TRUE if inside an event handler
eventhandler( ) Number TRUE if inside an event handler
executable( {expr}) Number 1 if executable {expr} exists
exists( {expr}) Number TRUE if {expr} exists
expand( {expr}) String expand special keywords in {expr}
filereadable( {file}) Number TRUE if {file} is a readable file
findfile( {name}[, {path}[, {count}]])
String Find fine {name} in {path}
String Find fine {name} in {path}
filewritable( {file}) Number TRUE if {file} is a writable file
fnamemodify( {fname}, {mods}) String modify file name
foldclosed( {lnum}) Number first line of fold at {lnum} if closed
foldclosedend( {lnum}) Number last line of fold at {lnum} if closed
foldclosed( {lnum}) Number first line of fold at {lnum} if closed
foldclosedend( {lnum}) Number last line of fold at {lnum} if closed
foldlevel( {lnum}) Number fold level at {lnum}
foldtext( ) String line displayed for closed fold
foldtext( ) String line displayed for closed fold
foreground( ) Number bring the Vim window to the foreground
getchar( [expr]) Number get one character from the user
getcharmod( ) Number modifiers for the last typed character
function( {name}) Funcref reference to function {name}
getchar( [expr]) Number get one character from the user
getcharmod( ) Number modifiers for the last typed character
getbufvar( {expr}, {varname}) variable {varname} in buffer {expr}
getcmdline() String return the current command-line
getcmdpos() Number return cursor position in command-line
@ -860,8 +967,8 @@ getfontname( [{name}]) String name of font being used
getftime( {fname}) Number last modification time of file
getftype( {fname}) String description of type of file {fname}
getline( {lnum}) String line {lnum} from current buffer
getreg( [{regname}]) String contents of register
getregtype( [{regname}]) String type of register
getreg( [{regname}]) String contents of register
getregtype( [{regname}]) String type of register
getwinposx() Number X coord in pixels of GUI Vim window
getwinposy() Number Y coord in pixels of GUI Vim window
getwinvar( {nr}, {varname}) variable {varname} in window {nr}
@ -876,19 +983,21 @@ histnr( {history}) Number highest index of a history
hlexists( {name}) Number TRUE if highlight group {name} exists
hlID( {name}) Number syntax ID of highlight group {name}
hostname() String name of the machine Vim is running on
iconv( {expr}, {from}, {to}) String convert encoding of {expr}
indent( {lnum}) Number indent of line {lnum}
iconv( {expr}, {from}, {to}) String convert encoding of {expr}
indent( {lnum}) Number indent of line {lnum}
input( {prompt} [, {text}]) String get input from the user
inputdialog( {p} [, {t} [, {c}]]) String like input() but in a GUI dialog
inputrestore() Number restore typeahead
inputsave() Number save and clear typeahead
inputrestore() Number restore typeahead
inputsave() Number save and clear typeahead
inputsecret( {prompt} [, {text}]) String like input() but hiding the text
insert( {list}, {item} [, {idx}]) List insert {item} in {list} [before {idx}]
isdirectory( {directory}) Number TRUE if {directory} is a directory
libcall( {lib}, {func}, {arg}) String call {func} in library {lib} with {arg}
len( {expr}) Number the length of {expr}
libcall( {lib}, {func}, {arg}) String call {func} in library {lib} with {arg}
libcallnr( {lib}, {func}, {arg}) Number idem, but return a Number
line( {expr}) Number line nr of cursor, last line or mark
line2byte( {lnum}) Number byte count of line {lnum}
lispindent( {lnum}) Number Lisp indent for line {lnum}
lispindent( {lnum}) Number Lisp indent for line {lnum}
localtime() Number current time
maparg( {name}[, {mode}]) String rhs of mapping {name} in mode {mode}
mapcheck( {name}[, {mode}]) String check for mappings matching {name}
@ -898,7 +1007,7 @@ matchend( {expr}, {pat}[, {start}[, {count}]])
Number position where {pat} ends in {expr}
matchstr( {expr}, {pat}[, {start}[, {count}]])
String {count}'th match of {pat} in {expr}
mode() String current editing mode
mode() String current editing mode
nextnonblank( {lnum}) Number line nr of non-blank line >= {lnum}
nr2char( {expr}) String single char with ASCII value {expr}
prevnonblank( {lnum}) Number line nr of non-blank line <= {lnum}
@ -910,29 +1019,31 @@ remote_peek( {serverid} [, {retvar}])
remote_read( {serverid}) String read reply string
remote_send( {server}, {string} [, {idvar}])
String send key sequence
rename( {from}, {to}) Number rename (move) file from {from} to {to}
repeat( {expr}, {count}) String repeat {expr} {count} times
resolve( {filename}) String get filename a shortcut points to
search( {pattern} [, {flags}]) Number search for {pattern}
remove( {list}, {idx}) any remove item {idx} from {list}
rename( {from}, {to}) Number rename (move) file from {from} to {to}
repeat( {expr}, {count}) String repeat {expr} {count} times
resolve( {filename}) String get filename a shortcut points to
search( {pattern} [, {flags}]) Number search for {pattern}
searchpair( {start}, {middle}, {end} [, {flags} [, {skip}]])
Number search for other end of start/end pair
Number search for other end of start/end pair
server2client( {clientid}, {string})
Number send reply string
serverlist() String get a list of available servers
setbufvar( {expr}, {varname}, {val}) set {varname} in buffer {expr} to {val}
setcmdpos( {pos}) Number set cursor position in command-line
setline( {lnum}, {line}) Number set line {lnum} to {line}
setreg( {n}, {v}[, {opt}]) Number set register to value and type
setreg( {n}, {v}[, {opt}]) Number set register to value and type
setwinvar( {nr}, {varname}, {val}) set {varname} in window {nr} to {val}
simplify( {filename}) String simplify filename as much as possible
simplify( {filename}) String simplify filename as much as possible
strftime( {format}[, {time}]) String time in specified format
stridx( {haystack}, {needle}) Number first index of {needle} in {haystack}
string( {expr}) String {expr} converted to a String
strlen( {expr}) Number length of the String {expr}
strpart( {src}, {start}[, {len}])
String {len} characters of {src} at {start}
strridx( {haystack}, {needle}) Number last index of {needle} in {haystack}
strtrans( {expr}) String translate string to make it printable
submatch( {nr}) String specific match in ":substitute"
submatch( {nr}) String specific match in ":substitute"
substitute( {expr}, {pat}, {sub}, {flags})
String all {pat} in {expr} replaced with {sub}
synID( {lnum}, {col}, {trans}) Number syntax ID at {lnum} and {col}
@ -953,15 +1064,23 @@ wincol() Number window column of the cursor
winheight( {nr}) Number height of window {nr}
winline() Number window line of the cursor
winnr() Number number of current window
winrestcmd() String returns command to restore window sizes
winrestcmd() String returns command to restore window sizes
winwidth( {nr}) Number width of window {nr}
append({lnum}, {string}) *append()*
Append the text {string} after line {lnum} in the current
buffer. {lnum} can be zero, to insert a line before the first
one. Returns 1 for failure ({lnum} out of range) or 0 for
success.
append({expr1}, {expr2}) *append()*
If {expr1} is a List: Append the item {expr2} to List {expr1}.
Returns the resulting List. Examples: >
:let alist = append([1, 2, 3], item)
:call append(mylist, "woodstock")
< Note that when {expr2} is a List it is appended as a single
item. Use |extend()| to concatenate Lists.
When {expr1} is not a List: Append the text {expr2} after line
{expr1} in the current buffer. {expr1} can be zero, to insert
a line before the first one. Returns 1 for failure ({expr1}
out of range or out of memory), 0 for success. Example: >
:let failed = append(line('$'), "# THE END")
<
*argc()*
argc() The result is the number of files in the argument list of the
current window. See |arglist|.
@ -1205,6 +1324,15 @@ confirm({msg} [, {choices} [, {default} [, {type}]]])
don't fit, a vertical layout is used anyway. For some systems
the horizontal layout is always used.
*copy()*
copy({expr}) Make a copy of {expr}. For Numbers and Strings this isn't
different from using {expr} directly.
When {expr} is a List a shallow copy is created. This means
that the original List can be changed without changing the
copy, and vise versa. But the items are identical, thus
changing an item changes the contents of both Lists. Also see
|deepcopy()|.
*cscope_connection()*
cscope_connection([{num} , {dbpath} [, {prepend}]])
Checks for the existence of a |cscope| connection. If no
@ -1257,10 +1385,22 @@ cursor({lnum}, {col}) *cursor()*
line.
If {col} is zero, the cursor will stay in the current column.
*delete()*
delete({fname}) Deletes the file by the name {fname}. The result is a Number,
deepcopy({expr}) *deepcopy()*
Make a copy of {expr}. For Numbers and Strings this isn't
different from using {expr} directly.
When {expr} is a List a full copy is created. This means
that the original List can be changed without changing the
copy, and vise versa. When an item is a List, a copy for it
is made, recursively. Thus changing an item in the copy does
not change the contents of the original List.
Also see |copy()|.
delete({fname}) *delete()*
Deletes the file by the name {fname}. The result is a Number,
which is 0 if the file was deleted successfully, and non-zero
when the deletion failed.
Use |remove()| to delete an item from a List.
*did_filetype()*
did_filetype() Returns non-zero when autocommands are being executed and the
@ -1545,6 +1685,10 @@ foreground() Move the Vim window to the foreground. Useful when sent from
{only in the Win32, Athena, Motif and GTK GUI versions and the
Win32 console version}
function({name}) *function()*
Return a Funcref variable that refers to function {name}.
{name} can be a user defined function or an internal function.
getchar([expr]) *getchar()*
Get a single character from the user. If it is an 8-bit
character, the result is a number. Otherwise a String is
@ -1995,12 +2139,34 @@ inputsecret({prompt} [, {text}]) *inputsecret()*
The result is a String, which is whatever the user actually
typed on the command-line in response to the issued prompt.
insert({list}, {item} [, {idx}]) *insert()*
Insert {item} at the start of List {list}.
If {idx} is specified insert {item} before the item with index
{idx}. If {idx} is zero it goes before the first item, just
like omitting {idx}. A negative {idx} is also possible, see
|list-index|. -1 inserts just before the last item.
Returns the resulting List. Examples: >
:let mylist = insert([2, 3, 5], 1)
:call insert(mylist, 4, -1)
:call insert(mylist, 6, len(mylist))
< The last example can be done simpler with |append()|.
Note that when {item} is a List it is inserted as a single
item. Use |extend()| to concatenate Lists.
isdirectory({directory}) *isdirectory()*
The result is a Number, which is non-zero when a directory
with the name {directory} exists. If {directory} doesn't
exist, or isn't a directory, the result is FALSE. {directory}
is any expression, which is used as a String.
*len()*
len({expr}) The result is a Number, which is the length of the argument.
When {expr} is a String or a Number the length in bytes is
used, as with |strlen()|.
When {expr} is a List the number of items in the List is
returned.
Otherwise an error is given.
*libcall()* *E364* *E368*
libcall({libname}, {funcname}, {argument})
Call function {funcname} in the run-time library {libname}
@ -2318,6 +2484,13 @@ remote_send({server}, {string} [, {idvar}])
\ 'server2client(expand("<client>"), "HELLO")<CR>')
remove({list}, {idx}) *remove()*
Remove the item at {idx} from List {list} and return it.
See |list-index| for possible values of {idx}.
Example: >
:echo "last item: " . remove(mylist, -1)
< Use |delete()| to remove a file.
rename({from}, {to}) *rename()*
Rename the file by the name {from} to the name {to}. This
should also work to move files across file systems. The
@ -2595,6 +2768,13 @@ stridx({haystack}, {needle}) *stridx()*
:echo stridx("Starting point", "Start") 0
:echo stridx("Starting point", "start") -1
<
*string()*
string({expr}) Return {expr} converted to a String.
{expr} type result ~
String identical
Number decimal representation
Funcref name of the function
*strlen()*
strlen({expr}) The result is a Number, which is the length of the String
{expr} in bytes. If you want to count the number of
@ -2603,6 +2783,9 @@ strlen({expr}) The result is a Number, which is the length of the String
:let len = strlen(substitute(str, ".", "x", "g"))
< Composing characters are not counted.
If the argument is a Number it is first converted to a String.
For other types an error is given.
Also see |len()|.
strpart({src}, {start}[, {len}]) *strpart()*
The result is a String, which is part of {src}, starting from
@ -3359,7 +3542,11 @@ This would call the function "my_func_whizz(parameter)".
:let {var-name} .. List the value of variable {var-name}. Several
variable names may be given.
:let List the values of all variables.
:let List the values of all variables. The type of the
variable is indicated before the value:
<nothing> String
# Number
* Funcref
*:unlet* *:unl* *E108*
:unl[et][!] {var-name} ...

11
runtime/doc/tags
View File

@ -3632,6 +3632,7 @@ FocusGained autocmd.txt /*FocusGained*
FocusLost autocmd.txt /*FocusLost*
Folding fold.txt /*Folding*
FuncUndefined autocmd.txt /*FuncUndefined*
Funcref eval.txt /*Funcref*
G motion.txt /*G*
GNOME gui_x11.txt /*GNOME*
GTK gui_x11.txt /*GTK*
@ -3658,6 +3659,7 @@ KVim gui_x11.txt /*KVim*
Korean mbyte.txt /*Korean*
L motion.txt /*L*
Linux-backspace options.txt /*Linux-backspace*
List eval.txt /*List*
M motion.txt /*M*
MDI starting.txt /*MDI*
MS-DOS os_msdos.txt /*MS-DOS*
@ -4277,6 +4279,7 @@ conversion-server mbyte.txt /*conversion-server*
convert-to-HTML syntax.txt /*convert-to-HTML*
convert-to-XHTML syntax.txt /*convert-to-XHTML*
convert-to-XML syntax.txt /*convert-to-XML*
copy() eval.txt /*copy()*
copy-diffs diff.txt /*copy-diffs*
copy-move change.txt /*copy-move*
copying uganda.txt /*copying*
@ -4409,6 +4412,7 @@ debugger-integration debugger.txt /*debugger-integration*
debugger-support debugger.txt /*debugger-support*
debugger.txt debugger.txt /*debugger.txt*
dec-mouse options.txt /*dec-mouse*
deepcopy() eval.txt /*deepcopy()*
definition-search tagsrch.txt /*definition-search*
definitions intro.txt /*definitions*
delete() eval.txt /*delete()*
@ -4610,6 +4614,7 @@ expr->= eval.txt /*expr->=*
expr->=# eval.txt /*expr->=#*
expr->=? eval.txt /*expr->=?*
expr->? eval.txt /*expr->?*
expr-[:] eval.txt /*expr-[:]*
expr-[] eval.txt /*expr-[]*
expr-barbar eval.txt /*expr-barbar*
expr-env eval.txt /*expr-env*
@ -4744,6 +4749,7 @@ ftplugin-name usr_05.txt /*ftplugin-name*
ftplugin-overrule filetype.txt /*ftplugin-overrule*
ftplugin-special usr_41.txt /*ftplugin-special*
ftplugins usr_05.txt /*ftplugins*
function() eval.txt /*function()*
function-argument eval.txt /*function-argument*
function-key intro.txt /*function-key*
function-list usr_41.txt /*function-list*
@ -4955,6 +4961,7 @@ hebrew hebrew.txt /*hebrew*
hebrew.txt hebrew.txt /*hebrew.txt*
help various.txt /*help*
help-context help.txt /*help-context*
help-tags tags 1
help-translated various.txt /*help-translated*
help-xterm-window various.txt /*help-xterm-window*
help.txt help.txt /*help.txt*
@ -5201,6 +5208,7 @@ ins-special-keys insert.txt /*ins-special-keys*
ins-special-special insert.txt /*ins-special-special*
ins-textwidth insert.txt /*ins-textwidth*
insert insert.txt /*insert*
insert() eval.txt /*insert()*
insert-index index.txt /*insert-index*
insert.txt insert.txt /*insert.txt*
insert_expand insert.txt /*insert_expand*
@ -5271,6 +5279,7 @@ last-position-jump eval.txt /*last-position-jump*
last_buffer_nr() eval.txt /*last_buffer_nr()*
lc_time-variable eval.txt /*lc_time-variable*
left-right-motions motion.txt /*left-right-motions*
len() eval.txt /*len()*
less various.txt /*less*
letter print.txt /*letter*
lex-syntax syntax.txt /*lex-syntax*
@ -6056,6 +6065,7 @@ status-line windows.txt /*status-line*
statusmsg-variable eval.txt /*statusmsg-variable*
strftime() eval.txt /*strftime()*
stridx() eval.txt /*stridx()*
string() eval.txt /*string()*
string-match eval.txt /*string-match*
strlen() eval.txt /*strlen()*
strpart() eval.txt /*strpart()*
@ -6483,6 +6493,7 @@ v_: cmdline.txt /*v_:*
v_< change.txt /*v_<*
v_<BS> change.txt /*v_<BS>*
v_<Del> change.txt /*v_<Del>*
v_<Esc> visual.txt /*v_<Esc>*
v_= change.txt /*v_=*
v_> change.txt /*v_>*
v_C change.txt /*v_C*

7
runtime/lang/menu_chinese(taiwan)_taiwan.950.vim Normal file
View File

@ -0,0 +1,7 @@
" Menu Translations: Traditional Chinese (for UNIX/Big5 Windows)
" Last Change: 2000 Nov 11
" $LANG on Windows 95/98/NT is Chinese(Taiwan)_Taiwan.950
" $LANG on Windows 2000/ME is Chinese_Taiwan.950
" Source the other one from here.
source <sfile>:p:h/menu_chinese_taiwan.950.vim

6
src/ops.c
View File

@ -5149,7 +5149,13 @@ write_viminfo_registers(fp)
if (i == TILDE_REGISTER)
continue;
#endif
/* Skip empty registers. */
num_lines = y_regs[i].y_size;
if (num_lines == 0
|| (num_lines == 1 && y_regs[i].y_type == MCHAR
&& STRLEN(y_regs[i].y_array[0]) == 0))
continue;
if (max_kbyte > 0)
{
/* Skip register if there is more text than the maximum size. */

4
src/proto/eval.pro
View File

@ -38,8 +38,8 @@ char_u *v_throwpoint __ARGS((char_u *oldval));
char_u *set_cmdarg __ARGS((exarg_T *eap, char_u *oldarg));
char_u *get_var_value __ARGS((char_u *name));
void new_script_vars __ARGS((scid_T id));
void var_init __ARGS((garray_T *gap));
void var_clear __ARGS((garray_T *gap));
void vars_init __ARGS((garray_T *gap));
void vars_clear __ARGS((garray_T *gap));
void ex_echo __ARGS((exarg_T *eap));
void ex_echohl __ARGS((exarg_T *eap));
void ex_execute __ARGS((exarg_T *eap));

4
src/version.h
View File

@ -36,5 +36,5 @@
#define VIM_VERSION_NODOT "vim70aa"
#define VIM_VERSION_SHORT "7.0aa"
#define VIM_VERSION_MEDIUM "7.0aa ALPHA"
#define VIM_VERSION_LONG "VIM - Vi IMproved 7.0aa ALPHA (2004 Dec 29)"
#define VIM_VERSION_LONG_DATE "VIM - Vi IMproved 7.0aa ALPHA (2004 Dec 29, compiled "
#define VIM_VERSION_LONG "VIM - Vi IMproved 7.0aa ALPHA (2004 Jan 3)"
#define VIM_VERSION_LONG_DATE "VIM - Vi IMproved 7.0aa ALPHA (2004 Jan 3, compiled "