If_perl

Nvim :help pages, generated from source using the tree-sitter-vimdoc parser.

The perl Interface to Vim perl
See provider-perl for more information.

1. Commands perl-commands

:perl :[range]perl {stmt} Execute perl statement {stmt}. The current package is "main". A simple check if the :perl command is working:
:perl print "Hello"
:[range]perl << [endmarker] {script} {endmarker} Execute perl script {script}. The {endmarker} after {script} must NOT be preceded by any white space.
If [endmarker] is omitted, it defaults to a dot '.' like for the :append and :insert commands.
Useful for including perl code in Vim scripts. Requires perl, see script-here.
Example:
function! MyVimMethod()
perl << EOF
sub my_vim_method
{
        print "Hello World!\n";
}
EOF
endfunction
To see what version of perl you have:
:perl print $^V
:perldo :[range]perldo {cmd} Execute perl command {cmd} for each line in the[range], with $_ being set to the test of each line in turn, without a trailing <EOL>. In addition to $_, $line and $linenr is also set to the line content and line number respectively. Setting $_ will change the text, but note that it is not possible to add or delete lines using this command. The default for [range] is the whole file: "1,$".
Examples: 
:perldo $_ = reverse($_);
:perldo $_ = "".$linenr." => $line";
One can use :perldo in conjunction with :perl to filter a range using perl. For example:
:perl << EOF
sub perl_vim_string_replace
{
    my $line = shift;
    my $needle = $vim->eval('@a');
    my $replacement = $vim->eval('@b');
    $line =~ s/$needle/$replacement/g;
    return $line;
}
EOF
:let @a='somevalue'
:let @b='newvalue'
:'<,'>perldo $_ = perl_vim_string_replace($_)
:perlfile :[range]perlfile {file} Execute the perl script in {file}. The whole argument is used as a single file name.
Both of these commands do essentially the same thing - they execute a piece of perl code, with the "current range" set to the given line range.
In the case of :perl, the code to execute is in the command-line. In the case of :perlfile, the code to execute is the contents of the given file.
perl commands cannot be used in the sandbox.
To pass arguments you need to set @ARGV explicitly. Example:
:perl @ARGV = ("foo", "bar");
:perlfile myscript.pl
Here are some examples perl-examples
:perl print "Hello"
:perl $current->line (uc ($current->line))
:perl my $str = $current->buffer->[42]; print "Set \$str to: $str"
Note that changes (such as the "use" statements) persist from one command to the next.

2. The VIM module perl-vim

Perl code gets all of its access to Neovim via the "VIM" module.
Overview
print "Hello"                                # displays a message
VIM::Msg("Hello")                        # displays a message
VIM::SetOption("ai")                        # sets a vim option
$nbuf = VIM::Buffers()                        # returns the number of buffers
@buflist = VIM::Buffers()                # returns array of all buffers
$mybuf = (VIM::Buffers('a.c'))[0]         # returns buffer object for 'a.c'
@winlist = VIM::Windows()                # returns array of all windows
$nwin = VIM::Windows()                        # returns the number of windows
($success, $v) = VIM::Eval('&path')        # $v: option 'path', $success: 1
($success, $v) = VIM::Eval('&xyz')        # $v: '' and $success: 0
$v = VIM::Eval('expand("<cfile>")')        # expands <cfile>
$curwin->SetHeight(10)                        # sets the window height
@pos = $curwin->Cursor()                # returns (row, col) array
@pos = (10, 10)
$curwin->Cursor(@pos)                        # sets cursor to @pos
$curwin->Cursor(10,10)                        # sets cursor to row 10 col 10
$mybuf = $curwin->Buffer()                # returns the buffer object for window
$curbuf->Name()                                # returns buffer name
$curbuf->Number()                        # returns buffer number
$curbuf->Count()                        # returns the number of lines
$l = $curbuf->Get(10)                        # returns line 10
@l = $curbuf->Get(1 .. 5)                # returns lines 1 through 5
$curbuf->Delete(10)                        # deletes line 10
$curbuf->Delete(10, 20)                        # delete lines 10 through 20
$curbuf->Append(10, "Line")                # appends a line
$curbuf->Append(10, "L1", "L2", "L3")        # appends 3 lines
@l = ("L1", "L2", "L3")
$curbuf->Append(10, @l)                        # appends L1, L2 and L3
$curbuf->Set(10, "Line")                # replaces line 10
$curbuf->Set(10, "Line1", "Line2")        # replaces lines 10 and 11
$curbuf->Set(10, @l)                        # replaces 3 lines
Module Functions:
perl-Msg VIM::Msg({msg}) Displays the message {msg}.
perl-SetOption VIM::SetOption({arg}) Sets a vim option. {arg} can be any argument that the ":set" command accepts. Note that this means that no spaces are allowed in the argument! See :set.
perl-Buffers VIM::Buffers([{bn}...]) With no arguments, returns a list of all the buffers in an array context or returns the number of buffers in a scalar context. For a list of buffer names or numbers {bn}, returns a list of the buffers matching {bn}, using the same rules as Vim's internal bufname() function. WARNING: the list becomes invalid when :bwipe is used.
perl-Windows VIM::Windows([{wn}...]) With no arguments, returns a list of all the windows in an array context or returns the number of windows in a scalar context. For a list of window numbers {wn}, returns a list of the windows with those numbers. WARNING: the list becomes invalid when a window is closed.
perl-DoCommand VIM::DoCommand({cmd}) Executes Ex command {cmd}.
perl-Eval VIM::Eval({expr}) Evaluates {expr} and returns (success, value) in list context or just value in scalar context. success=1 indicates that val contains the value of {expr}; success=0 indicates a failure to evaluate the expression. '@x' returns the contents of register x, '&x' returns the value of option x, 'x' returns the value of internal variables x, and '$x' is equivalent to perl's $ENV{x}. All functions accessible from the command-line are valid for {expr}. A List is turned into a string by joining the items and inserting line breaks.
perl-Blob VIM::Blob({expr}) Return Blob literal string 0zXXXX from scalar value.

3. VIM::Buffer objects perl-buffer

Methods:
perl-Buffer-Name Name() Returns the filename for the Buffer.
perl-Buffer-Number Number() Returns the number of the Buffer.
perl-Buffer-Count Count() Returns the number of lines in the Buffer.
perl-Buffer-Get Get({lnum}, {lnum}?, ...) Returns a text string of line {lnum} in the Buffer for each {lnum} specified. An array can be passed with a list of {lnum}'s specified.
perl-Buffer-Delete Delete({lnum}, {lnum}?) Deletes line {lnum} in the Buffer. With the second {lnum}, deletes the range of lines from the first {lnum} to the second {lnum}.
perl-Buffer-Append Append({lnum}, {line}, {line}?, ...) Appends each {line} string after Buffer line {lnum}. The list of {line}s can be an array.
perl-Buffer-Set Set({lnum}, {line}, {line}?, ...) Replaces one or more Buffer lines with specified {lines}s, starting at Buffer line {lnum}. The list of {line}s can be an array. If the arguments are invalid, replacement does not occur.

4. VIM::Window objects perl-window

Methods: perl-Window-SetHeight SetHeight({height}) Sets the Window height to {height}, within screen limits.
perl-Window-GetCursor Cursor({row}?, {col}?) With no arguments, returns a (row, col) array for the current cursor position in the Window. With {row} and {col} arguments, sets the Window's cursor position to {row} and {col}. Note that {col} is numbered from 0, Perl-fashion, and thus is one less than the value in Vim's ruler.
Buffer() perl-Window-Buffer Returns the Buffer object corresponding to the given Window.

5. Lexical variables perl-globals

There are multiple lexical variables.
$curwin The current Window object. $curbuf The current Buffer object. $vim A Neovim::Ext object. $nvim The same as $nvim. $current A Neovim::Ext::Current object.
These are also available via the "main" package:
$main::curwin The current Window object. $main::curbuf The current Buffer object.