diff options
Diffstat (limited to 'runtime/doc/if_pyth.txt')
| -rw-r--r-- | runtime/doc/if_pyth.txt | 299 |
1 files changed, 299 insertions, 0 deletions
diff --git a/runtime/doc/if_pyth.txt b/runtime/doc/if_pyth.txt new file mode 100644 index 000000000..df75fcf56 --- /dev/null +++ b/runtime/doc/if_pyth.txt @@ -0,0 +1,299 @@ +*if_pyth.txt* For Vim version 7.0aa. Last change: 2004 Feb 28 + + + VIM REFERENCE MANUAL by Paul Moore + + +The Python Interface to Vim *python* *Python* + +1. Commands |python-commands| +2. The vim module |python-vim| +3. Buffer objects |python-buffer| +4. Range objects |python-range| +5. Window objects |python-window| + +{Vi does not have any of these commands} + +The Python interface is available only when Vim was compiled with the +|+python| feature. + +============================================================================== +1. Commands *python-commands* + + *:python* *:py* *E205* *E263* *E264* +:[range]py[thon] {stmt} + Execute Python statement {stmt}. + +:[range]py[thon] << {endmarker} +{script} +{endmarker} + Execute Python script {script}. + Note: This command doesn't work when the Python + feature wasn't compiled in. To avoid errors, see + |script-here|. + +{endmarker} must NOT be preceded by any white space. If {endmarker} is +omitted from after the "<<", a dot '.' must be used after {script}, like +for the |:append| and |:insert| commands. +This form of the |:python| command is mainly useful for including python code +in Vim scripts. + +Example: > + function! IcecreamInitialize() + python << EOF + class StrawberryIcecream: + def __call__(self): + print 'EAT ME' + EOF + endfunction +< +Note: Python is very sensitive to the indenting. Also make sure the "class" +line and "EOF" do not have any indent. + + *:pyfile* *:pyf* +:[range]pyf[ile] {file} + Execute the Python script in {file}. The whole + argument is used as a single file name. {not in Vi} + +Both of these commands do essentially the same thing - they execute a piece of +Python code, with the "current range" |python-range| set to the given line +range. + +In the case of :python, the code to execute is in the command-line. +In the case of :pyfile, the code to execute is the contents of the given file. + +Python commands cannot be used in the |sandbox|. + +To pass arguments you need to set sys.argv[] explicitly. Example: > + + :python import sys + :python sys.argv = ["foo", "bar"] + :pyfile myscript.py + +Here are some examples *python-examples* > + + :python from vim import * + :python from string import upper + :python current.line = upper(current.line) + :python print "Hello" + :python str = current.buffer[42] + +(Note that changes - like the imports - persist from one command to the next, +just like in the Python interpreter.) + +============================================================================== +2. The vim module *python-vim* + +Python code gets all of its access to vim (with one exception - see +|python-output| below) via the "vim" module. The vim module implements two +methods, three constants, and one error object. You need to import the vim +module before using it: > + :python import vim + +Overview > + print "Hello" # displays a message + vim.command(cmd) # execute an ex command + w = vim.windows[n] # gets window "n" + cw = vim.current.window # gets the current window + b = vim.buffers[n] # gets buffer "n" + cb = vim.current.buffer # gets the current buffer + w.height = lines # sets the window height + w.cursor = (row, col) # sets the window cursor position + pos = w.cursor # gets a tuple (row, col) + name = b.name # gets the buffer file name + line = b[n] # gets a line from the buffer + lines = b[n:m] # gets a list of lines + num = len(b) # gets the number of lines + b[n] = str # sets a line in the buffer + b[n:m] = [str1, str2, str3] # sets a number of lines at once + del b[n] # deletes a line + del b[n:m] # deletes a number of lines + + +Methods of the "vim" module + +vim.command(str) *python-command* + Executes the vim (ex-mode) command str. Returns None. + Examples: > + vim.command("set tw=72") + vim.command("%s/aaa/bbb/g") +< The following definition executes Normal mode commands: > + def normal(str): + vim.command("normal "+str) + # Note the use of single quotes to delimit a string containing + # double quotes + normal('"a2dd"aP') +< *E659* + The ":python" command cannot be used recursively with Python 2.2 and + older. This only works with Python 2.3 and later: > + :python vim.command("python print 'Hello again Python'") + +vim.eval(str) *python-eval* + Evaluates the expression str using the vim internal expression + evaluator (see |expression|). Returns the expression result as a + string. + Examples: > + text_width = vim.eval("&tw") + str = vim.eval("12+12") # NB result is a string! Use + # string.atoi() to convert to + # a number. + +Error object of the "vim" module + +vim.error *python-error* + Upon encountering a Vim error, Python raises an exception of type + vim.error. + Example: > + try: + vim.command("put a") + except vim.error: + # nothing in register a + +Constants of the "vim" module + + Note that these are not actually constants - you could reassign them. + But this is silly, as you would then lose access to the vim objects + to which the variables referred. + +vim.buffers *python-buffers* + A sequence object providing access to the list of vim buffers. The + object supports the following operations: > + b = vim.buffers[i] # Indexing (read-only) + b in vim.buffers # Membership test + n = len(vim.buffers) # Number of elements + for b in vim.buffers: # Sequential access +< +vim.windows *python-windows* + A sequence object providing access to the list of vim windows. The + object supports the following operations: > + w = vim.windows[i] # Indexing (read-only) + w in vim.windows # Membership test + n = len(vim.windows) # Number of elements + for w in vim.windows: # Sequential access +< +vim.current *python-current* + An object providing access (via specific attributes) to various + "current" objects available in vim: + vim.current.line The current line (RW) String + vim.current.buffer The current buffer (RO) Buffer + vim.current.window The current window (RO) Window + vim.current.range The current line range (RO) Range + + The last case deserves a little explanation. When the :python or + :pyfile command specifies a range, this range of lines becomes the + "current range". A range is a bit like a buffer, but with all access + restricted to a subset of lines. See |python-range| for more details. + + +Output from Python *python-output* + Vim displays all Python code output in the Vim message area. Normal + output appears as information messages, and error output appears as + error messages. + + In implementation terms, this means that all output to sys.stdout + (including the output from print statements) appears as information + messages, and all output to sys.stderr (including error tracebacks) + appears as error messages. + + *python-input* + Input (via sys.stdin, including input() and raw_input()) is not + supported, and may cause the program to crash. This should probably be + fixed. + +============================================================================== +3. Buffer objects *python-buffer* + +Buffer objects represent vim buffers. You can obtain them in a number of ways: + - via vim.current.buffer (|python-current|) + - from indexing vim.buffers (|python-buffers|) + - from the "buffer" attribute of a window (|python-window|) + +Buffer objects have one read-only attribute - name - the full file name for +the buffer. They also have three methods (append, mark, and range; see below). + +You can also treat buffer objects as sequence objects. In this context, they +act as if they were lists (yes, they are mutable) of strings, with each +element being a line of the buffer. All of the usual sequence operations, +including indexing, index assignment, slicing and slice assignment, work as +you would expect. Note that the result of indexing (slicing) a buffer is a +string (list of strings). This has one unusual consequence - b[:] is different +from b. In particular, "b[:] = None" deletes the whole of the buffer, whereas +"b = None" merely updates the variable b, with no effect on the buffer. + +Buffer indexes start at zero, as is normal in Python. This differs from vim +line numbers, which start from 1. This is particularly relevant when dealing +with marks (see below) which use vim line numbers. + +The buffer object methods are: + b.append(str) Append a line to the buffer + b.append(list) Append a list of lines to the buffer + Note that the option of supplying a list of strings to + the append method differs from the equivalent method + for Python's built-in list objects. + b.mark(name) Return a tuple (row,col) representing the position + of the named mark (can also get the []"<> marks) + b.range(s,e) Return a range object (see |python-range|) which + represents the part of the given buffer between line + numbers s and e |inclusive|. + +Examples (assume b is the current buffer) > + print b.name # write the buffer file name + b[0] = "hello!!!" # replace the top line + b[:] = None # delete the whole buffer + del b[:] # delete the whole buffer (same as above) + b[0:0] = [ "a line" ] # add a line at the top + del b[2] # delete a line (the third) + b.append("bottom") # add a line at the bottom + n = len(b) # number of lines + (row,col) = b.mark('a') # named mark + r = b.range(1,5) # a sub-range of the buffer + +============================================================================== +4. Range objects *python-range* + +Range objects represent a part of a vim buffer. You can obtain them in a +number of ways: + - via vim.current.range (|python-current|) + - from a buffer's range() method (|python-buffer|) + +A range object is almost identical in operation to a buffer object. However, +all operations are restricted to the lines within the range (this line range +can, of course, change as a result of slice assignments, line deletions, or +the range.append() method). + +The range object attributes are: + r.start Index of first line into the buffer + r.end Index of last line into the buffer + +The range object methods are: + r.append(str) Append a line to the range + r.append(list) Append a list of lines to the range + Note that the option of supplying a list of strings to + the append method differs from the equivalent method + for Python's built-in list objects. + +Example (assume r is the current range): + # Send all lines in a range to the default printer + vim.command("%d,%dhardcopy!" % (r.start+1,r.end+1)) + +============================================================================== +5. Window objects *python-window* + +Window objects represent vim windows. You can obtain them in a number of ways: + - via vim.current.window (|python-current|) + - from indexing vim.windows (|python-windows|) + +You can manipulate window objects only through their attributes. They have no +methods, and no sequence or other interface. + +Window attributes are: + buffer (read-only) The buffer displayed in this window + cursor (read-write) The current cursor position in the window + This is a tuple, (row,col). + height (read-write) The window height, in rows + width (read-write) The window width, in columns +The height attribute is writable only if the screen is split horizontally. +The width attribute is writable only if the screen is split vertically. + +============================================================================== + vim:tw=78:ts=8:ft=help:norl: |