Mercurial > vim
annotate runtime/doc/if_pyth.txt @ 4379:a2f03b41dca7 v7.3.938
updated for version 7.3.938
Problem: Python: not easy to get to window number.
Solution: Add vim.window.number. (ZyX)
| author | Bram Moolenaar <bram@vim.org> |
|---|---|
| date | Sun, 12 May 2013 19:00:41 +0200 |
| parents | cf1d93a3914a |
| children | e2db42528a5b |
| rev | line source |
|---|---|
| 4358 | 1 *if_pyth.txt* For Vim version 7.3. Last change: 2013 May 06 |
| 7 | 2 |
| 3 | |
| 4 VIM REFERENCE MANUAL by Paul Moore | |
| 5 | |
| 6 | |
| 7 The Python Interface to Vim *python* *Python* | |
| 8 | |
| 3682 | 9 1. Commands |python-commands| |
| 10 2. The vim module |python-vim| | |
| 11 3. Buffer objects |python-buffer| | |
| 12 4. Range objects |python-range| | |
| 13 5. Window objects |python-window| | |
| 14 6. pyeval(), py3eval() Vim functions |python-pyeval| | |
| 15 7. Dynamic loading |python-dynamic| | |
| 16 8. Python 3 |python3| | |
| 7 | 17 |
| 18 {Vi does not have any of these commands} | |
| 19 | |
|
2350
06feaf4fe36a
Rename some "python3" symbols to "py3", as the command name.
Bram Moolenaar <bram@vim.org>
parents:
2345
diff
changeset
|
20 The Python 2.x interface is available only when Vim was compiled with the |
| 7 | 21 |+python| feature. |
|
2350
06feaf4fe36a
Rename some "python3" symbols to "py3", as the command name.
Bram Moolenaar <bram@vim.org>
parents:
2345
diff
changeset
|
22 The Python 3 interface is available only when Vim was compiled with the |
|
06feaf4fe36a
Rename some "python3" symbols to "py3", as the command name.
Bram Moolenaar <bram@vim.org>
parents:
2345
diff
changeset
|
23 |+python3| feature. |
| 7 | 24 |
| 25 ============================================================================== | |
| 26 1. Commands *python-commands* | |
| 27 | |
| 28 *:python* *:py* *E205* *E263* *E264* | |
| 29 :[range]py[thon] {stmt} | |
| 3750 | 30 Execute Python statement {stmt}. A simple check if |
| 31 the `:python` command is working: > | |
| 32 :python print "Hello" | |
| 7 | 33 |
| 34 :[range]py[thon] << {endmarker} | |
| 35 {script} | |
| 36 {endmarker} | |
| 37 Execute Python script {script}. | |
| 38 Note: This command doesn't work when the Python | |
| 39 feature wasn't compiled in. To avoid errors, see | |
| 40 |script-here|. | |
| 41 | |
| 42 {endmarker} must NOT be preceded by any white space. If {endmarker} is | |
| 43 omitted from after the "<<", a dot '.' must be used after {script}, like | |
| 44 for the |:append| and |:insert| commands. | |
| 45 This form of the |:python| command is mainly useful for including python code | |
| 46 in Vim scripts. | |
| 47 | |
| 48 Example: > | |
| 49 function! IcecreamInitialize() | |
| 50 python << EOF | |
| 51 class StrawberryIcecream: | |
| 52 def __call__(self): | |
| 53 print 'EAT ME' | |
| 54 EOF | |
| 55 endfunction | |
| 56 < | |
| 4073 | 57 Note: Python is very sensitive to the indenting. Make sure the "class" line |
| 58 and "EOF" do not have any indent. | |
| 7 | 59 |
| 60 *:pyfile* *:pyf* | |
| 61 :[range]pyf[ile] {file} | |
| 62 Execute the Python script in {file}. The whole | |
| 63 argument is used as a single file name. {not in Vi} | |
| 64 | |
| 65 Both of these commands do essentially the same thing - they execute a piece of | |
| 66 Python code, with the "current range" |python-range| set to the given line | |
| 67 range. | |
| 68 | |
| 69 In the case of :python, the code to execute is in the command-line. | |
| 70 In the case of :pyfile, the code to execute is the contents of the given file. | |
| 71 | |
| 72 Python commands cannot be used in the |sandbox|. | |
| 73 | |
| 74 To pass arguments you need to set sys.argv[] explicitly. Example: > | |
| 75 | |
| 76 :python import sys | |
| 77 :python sys.argv = ["foo", "bar"] | |
| 78 :pyfile myscript.py | |
| 79 | |
| 80 Here are some examples *python-examples* > | |
| 81 | |
| 82 :python from vim import * | |
| 83 :python from string import upper | |
| 84 :python current.line = upper(current.line) | |
| 85 :python print "Hello" | |
| 86 :python str = current.buffer[42] | |
| 87 | |
| 88 (Note that changes - like the imports - persist from one command to the next, | |
| 89 just like in the Python interpreter.) | |
| 90 | |
| 91 ============================================================================== | |
| 92 2. The vim module *python-vim* | |
| 93 | |
| 94 Python code gets all of its access to vim (with one exception - see | |
| 236 | 95 |python-output| below) via the "vim" module. The vim module implements two |
| 7 | 96 methods, three constants, and one error object. You need to import the vim |
| 97 module before using it: > | |
| 98 :python import vim | |
| 99 | |
| 100 Overview > | |
| 20 | 101 :py print "Hello" # displays a message |
|
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
102 :py vim.command(cmd) # execute an Ex command |
| 20 | 103 :py w = vim.windows[n] # gets window "n" |
| 104 :py cw = vim.current.window # gets the current window | |
| 105 :py b = vim.buffers[n] # gets buffer "n" | |
| 106 :py cb = vim.current.buffer # gets the current buffer | |
| 107 :py w.height = lines # sets the window height | |
| 108 :py w.cursor = (row, col) # sets the window cursor position | |
| 109 :py pos = w.cursor # gets a tuple (row, col) | |
| 110 :py name = b.name # gets the buffer file name | |
| 111 :py line = b[n] # gets a line from the buffer | |
| 112 :py lines = b[n:m] # gets a list of lines | |
| 113 :py num = len(b) # gets the number of lines | |
| 114 :py b[n] = str # sets a line in the buffer | |
| 115 :py b[n:m] = [str1, str2, str3] # sets a number of lines at once | |
| 116 :py del b[n] # deletes a line | |
| 117 :py del b[n:m] # deletes a number of lines | |
| 7 | 118 |
| 119 | |
| 120 Methods of the "vim" module | |
| 121 | |
| 122 vim.command(str) *python-command* | |
| 236 | 123 Executes the vim (ex-mode) command str. Returns None. |
| 7 | 124 Examples: > |
| 20 | 125 :py vim.command("set tw=72") |
| 126 :py vim.command("%s/aaa/bbb/g") | |
| 7 | 127 < The following definition executes Normal mode commands: > |
| 128 def normal(str): | |
| 129 vim.command("normal "+str) | |
| 130 # Note the use of single quotes to delimit a string containing | |
| 131 # double quotes | |
| 132 normal('"a2dd"aP') | |
| 133 < *E659* | |
| 134 The ":python" command cannot be used recursively with Python 2.2 and | |
| 135 older. This only works with Python 2.3 and later: > | |
| 20 | 136 :py vim.command("python print 'Hello again Python'") |
| 7 | 137 |
| 138 vim.eval(str) *python-eval* | |
| 139 Evaluates the expression str using the vim internal expression | |
| 633 | 140 evaluator (see |expression|). Returns the expression result as: |
| 141 - a string if the Vim expression evaluates to a string or number | |
| 142 - a list if the Vim expression evaluates to a Vim list | |
| 856 | 143 - a dictionary if the Vim expression evaluates to a Vim dictionary |
| 633 | 144 Dictionaries and lists are recursively expanded. |
| 7 | 145 Examples: > |
| 20 | 146 :py text_width = vim.eval("&tw") |
| 147 :py str = vim.eval("12+12") # NB result is a string! Use | |
| 7 | 148 # string.atoi() to convert to |
| 149 # a number. | |
| 150 | |
| 856 | 151 :py tagList = vim.eval('taglist("eval_expr")') |
| 633 | 152 < The latter will return a python list of python dicts, for instance: |
| 153 [{'cmd': '/^eval_expr(arg, nextcmd)$/', 'static': 0, 'name': | |
| 154 'eval_expr', 'kind': 'f', 'filename': './src/eval.c'}] | |
| 155 | |
| 3682 | 156 vim.bindeval(str) *python-bindeval* |
| 157 Like |python-eval|, but | |
| 158 1. if expression evaluates to |List| or |Dictionary| it is returned as | |
| 159 vimlist or vimdictionary python type that are connected to original | |
| 160 list or dictionary. Thus modifications to these objects imply | |
| 161 modifications of the original. | |
| 3830 | 162 |
| 163 Additionally, vimlist and vimdictionary type have read-write | |
| 164 `.locked` attribute that returns | |
| 165 Value Meaning ~ | |
| 166 zero Variable is not locked | |
| 167 vim.VAR_LOCKED Variable is locked, but can be unlocked | |
| 3847 | 168 vim.VAR_FIXED Variable is locked and can't be unlocked |
| 3830 | 169 integer constants. If variable is not fixed, you can do |
| 170 `var.locked=True` to lock it and `var.locked=False` to unlock. | |
| 171 There is no recursive locking like |:lockvar|! does. There is also | |
| 172 no way to lock a specific key or check whether it is locked (in any | |
| 173 case these locks are ignored by anything except |:let|: |extend()| | |
| 174 does not care, neither does python interface). | |
| 175 | |
| 176 Vimdictionary type also supports `.scope` attribute which is one of | |
| 177 Value Meaning ~ | |
| 178 zero Dictionary is not a scope one | |
| 179 vim.VAR_DEF_SCOPE Function-local or global scope dictionary | |
| 180 vim.VAR_SCOPE Other scope dictionary | |
| 181 | |
| 3682 | 182 2. if expression evaluates to a function reference, then it returns |
| 183 callable vimfunction object. Use self keyword argument to assign | |
| 184 |self| object for dictionary functions. | |
| 185 | |
| 186 Note: this function has the same behavior as |lua-eval| (except that | |
| 187 lua does not support running vim functions), |python-eval| is | |
| 188 kept for backwards compatibility in order not to make scripts | |
| 189 relying on outputs of vim.eval() being a copy of original or | |
| 190 vim.eval("1") returning a string. | |
| 191 | |
| 633 | 192 |
| 193 | |
| 7 | 194 Error object of the "vim" module |
| 195 | |
| 196 vim.error *python-error* | |
| 197 Upon encountering a Vim error, Python raises an exception of type | |
| 198 vim.error. | |
| 199 Example: > | |
| 200 try: | |
| 201 vim.command("put a") | |
| 202 except vim.error: | |
| 203 # nothing in register a | |
| 204 | |
| 205 Constants of the "vim" module | |
| 206 | |
| 207 Note that these are not actually constants - you could reassign them. | |
| 208 But this is silly, as you would then lose access to the vim objects | |
| 209 to which the variables referred. | |
| 210 | |
| 211 vim.buffers *python-buffers* | |
| 236 | 212 A sequence object providing access to the list of vim buffers. The |
| 7 | 213 object supports the following operations: > |
| 20 | 214 :py b = vim.buffers[i] # Indexing (read-only) |
| 215 :py b in vim.buffers # Membership test | |
| 216 :py n = len(vim.buffers) # Number of elements | |
| 217 :py for b in vim.buffers: # Sequential access | |
| 7 | 218 < |
| 219 vim.windows *python-windows* | |
| 236 | 220 A sequence object providing access to the list of vim windows. The |
| 7 | 221 object supports the following operations: > |
| 20 | 222 :py w = vim.windows[i] # Indexing (read-only) |
| 223 :py w in vim.windows # Membership test | |
| 224 :py n = len(vim.windows) # Number of elements | |
| 225 :py for w in vim.windows: # Sequential access | |
| 7 | 226 < |
| 227 vim.current *python-current* | |
| 228 An object providing access (via specific attributes) to various | |
| 229 "current" objects available in vim: | |
| 230 vim.current.line The current line (RW) String | |
| 231 vim.current.buffer The current buffer (RO) Buffer | |
| 232 vim.current.window The current window (RO) Window | |
| 233 vim.current.range The current line range (RO) Range | |
| 234 | |
| 236 | 235 The last case deserves a little explanation. When the :python or |
| 7 | 236 :pyfile command specifies a range, this range of lines becomes the |
| 236 | 237 "current range". A range is a bit like a buffer, but with all access |
| 238 restricted to a subset of lines. See |python-range| for more details. | |
| 7 | 239 |
| 4323 | 240 vim.vars *python-vars* |
| 241 vim.vvars *python-vvars* | |
| 242 Dictionary-like objects holding dictionaries with global (|g:|) and | |
| 243 vim (|v:|) variables respectively. Identical to `vim.bindeval("g:")`, | |
| 244 but faster. | |
| 7 | 245 |
| 4350 | 246 vim.options *python-options* |
| 247 Object partly supporting mapping protocol (supports setting and | |
| 248 getting items) providing a read-write access to global options. | |
| 249 Note: unlike |:set| this provides access only to global options. You | |
| 250 cannot use this object to obtain or set local options' values or | |
| 251 access local-only options in any fashion. Raises KeyError if no global | |
| 252 option with such name exists (i.e. does not raise KeyError for | |
| 253 |global-local| options and global only options, but does for window- | |
| 254 and buffer-local ones). Use |python-buffer| objects to access to | |
| 255 buffer-local options and |python-window| objects to access to | |
| 256 window-local options. | |
| 257 | |
| 7 | 258 Output from Python *python-output* |
| 259 Vim displays all Python code output in the Vim message area. Normal | |
| 260 output appears as information messages, and error output appears as | |
| 261 error messages. | |
| 262 | |
| 263 In implementation terms, this means that all output to sys.stdout | |
| 264 (including the output from print statements) appears as information | |
| 265 messages, and all output to sys.stderr (including error tracebacks) | |
| 266 appears as error messages. | |
| 267 | |
| 268 *python-input* | |
| 269 Input (via sys.stdin, including input() and raw_input()) is not | |
| 236 | 270 supported, and may cause the program to crash. This should probably be |
| 7 | 271 fixed. |
| 272 | |
| 273 ============================================================================== | |
| 274 3. Buffer objects *python-buffer* | |
| 275 | |
| 236 | 276 Buffer objects represent vim buffers. You can obtain them in a number of ways: |
| 7 | 277 - via vim.current.buffer (|python-current|) |
| 278 - from indexing vim.buffers (|python-buffers|) | |
| 279 - from the "buffer" attribute of a window (|python-window|) | |
| 280 | |
| 3312 | 281 Buffer objects have two read-only attributes - name - the full file name for |
| 282 the buffer, and number - the buffer number. They also have three methods | |
| 283 (append, mark, and range; see below). | |
| 7 | 284 |
| 236 | 285 You can also treat buffer objects as sequence objects. In this context, they |
| 7 | 286 act as if they were lists (yes, they are mutable) of strings, with each |
| 236 | 287 element being a line of the buffer. All of the usual sequence operations, |
| 7 | 288 including indexing, index assignment, slicing and slice assignment, work as |
| 236 | 289 you would expect. Note that the result of indexing (slicing) a buffer is a |
| 290 string (list of strings). This has one unusual consequence - b[:] is different | |
| 291 from b. In particular, "b[:] = None" deletes the whole of the buffer, whereas | |
| 7 | 292 "b = None" merely updates the variable b, with no effect on the buffer. |
| 293 | |
| 236 | 294 Buffer indexes start at zero, as is normal in Python. This differs from vim |
| 295 line numbers, which start from 1. This is particularly relevant when dealing | |
| 7 | 296 with marks (see below) which use vim line numbers. |
| 297 | |
| 4350 | 298 The buffer object attributes are: |
| 299 b.vars Dictionary-like object used to access | |
| 300 |buffer-variable|s. | |
| 301 b.options Mapping object (supports item getting, setting and | |
| 302 deleting) that provides access to buffer-local options | |
| 303 and buffer-local values of |global-local| options. Use | |
| 304 |python-window|.options if option is window-local, | |
| 305 this object will raise KeyError. If option is | |
| 306 |global-local| and local value is missing getting it | |
| 307 will return None. | |
| 308 | |
| 7 | 309 The buffer object methods are: |
| 310 b.append(str) Append a line to the buffer | |
|
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
311 b.append(str, nr) Idem, below line "nr" |
| 7 | 312 b.append(list) Append a list of lines to the buffer |
| 313 Note that the option of supplying a list of strings to | |
| 314 the append method differs from the equivalent method | |
| 315 for Python's built-in list objects. | |
|
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
316 b.append(list, nr) Idem, below line "nr" |
| 7 | 317 b.mark(name) Return a tuple (row,col) representing the position |
| 318 of the named mark (can also get the []"<> marks) | |
| 319 b.range(s,e) Return a range object (see |python-range|) which | |
| 320 represents the part of the given buffer between line | |
| 321 numbers s and e |inclusive|. | |
| 322 | |
| 20 | 323 Note that when adding a line it must not contain a line break character '\n'. |
| 324 A trailing '\n' is allowed and ignored, so that you can do: > | |
| 325 :py b.append(f.readlines()) | |
| 326 | |
| 7 | 327 Examples (assume b is the current buffer) > |
| 20 | 328 :py print b.name # write the buffer file name |
| 329 :py b[0] = "hello!!!" # replace the top line | |
| 330 :py b[:] = None # delete the whole buffer | |
| 331 :py del b[:] # delete the whole buffer | |
| 332 :py b[0:0] = [ "a line" ] # add a line at the top | |
| 333 :py del b[2] # delete a line (the third) | |
| 334 :py b.append("bottom") # add a line at the bottom | |
| 335 :py n = len(b) # number of lines | |
| 336 :py (row,col) = b.mark('a') # named mark | |
| 337 :py r = b.range(1,5) # a sub-range of the buffer | |
| 4323 | 338 :py b.vars["foo"] = "bar" # assign b:foo variable |
| 4350 | 339 :py b.options["ff"] = "dos" # set fileformat |
| 340 :py del b.options["ar"] # same as :set autoread< | |
| 7 | 341 |
| 342 ============================================================================== | |
| 343 4. Range objects *python-range* | |
| 344 | |
| 236 | 345 Range objects represent a part of a vim buffer. You can obtain them in a |
| 7 | 346 number of ways: |
| 347 - via vim.current.range (|python-current|) | |
| 348 - from a buffer's range() method (|python-buffer|) | |
| 349 | |
| 236 | 350 A range object is almost identical in operation to a buffer object. However, |
| 7 | 351 all operations are restricted to the lines within the range (this line range |
| 352 can, of course, change as a result of slice assignments, line deletions, or | |
| 353 the range.append() method). | |
| 354 | |
| 355 The range object attributes are: | |
| 356 r.start Index of first line into the buffer | |
| 357 r.end Index of last line into the buffer | |
| 358 | |
| 359 The range object methods are: | |
| 360 r.append(str) Append a line to the range | |
|
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
361 r.append(str, nr) Idem, after line "nr" |
| 7 | 362 r.append(list) Append a list of lines to the range |
| 363 Note that the option of supplying a list of strings to | |
| 364 the append method differs from the equivalent method | |
| 365 for Python's built-in list objects. | |
|
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
366 r.append(list, nr) Idem, after line "nr" |
| 7 | 367 |
| 368 Example (assume r is the current range): | |
| 369 # Send all lines in a range to the default printer | |
| 370 vim.command("%d,%dhardcopy!" % (r.start+1,r.end+1)) | |
| 371 | |
| 372 ============================================================================== | |
| 373 5. Window objects *python-window* | |
| 374 | |
| 236 | 375 Window objects represent vim windows. You can obtain them in a number of ways: |
| 7 | 376 - via vim.current.window (|python-current|) |
| 377 - from indexing vim.windows (|python-windows|) | |
| 378 | |
| 236 | 379 You can manipulate window objects only through their attributes. They have no |
| 7 | 380 methods, and no sequence or other interface. |
| 381 | |
| 382 Window attributes are: | |
| 383 buffer (read-only) The buffer displayed in this window | |
| 384 cursor (read-write) The current cursor position in the window | |
| 385 This is a tuple, (row,col). | |
| 386 height (read-write) The window height, in rows | |
| 387 width (read-write) The window width, in columns | |
| 4323 | 388 vars (read-only) The window |w:| variables. Attribute is |
| 389 unassignable, but you can change window | |
| 390 variables this way | |
| 4350 | 391 options (read-only) The window-local options. Attribute is |
| 392 unassignable, but you can change window | |
| 393 options this way. Provides access only to | |
| 394 window-local options, for buffer-local use | |
| 395 |python-buffer| and for global ones use | |
| 396 |python-options|. If option is |global-local| | |
| 397 and local value is missing getting it will | |
| 398 return None. | |
| 4379 | 399 number (read-only) Window number. The first window has number 1. |
| 400 This is zero in case it cannot be determined | |
| 401 (e.g. when the window object belongs to other | |
| 402 tab page). | |
| 7 | 403 The height attribute is writable only if the screen is split horizontally. |
| 404 The width attribute is writable only if the screen is split vertically. | |
| 405 | |
| 406 ============================================================================== | |
| 3682 | 407 6. pyeval() and py3eval() Vim functions *python-pyeval* |
| 408 | |
| 409 To facilitate bi-directional interface, you can use |pyeval()| and |py3eval()| | |
| 410 functions to evaluate Python expressions and pass their values to VimL. | |
| 411 | |
| 412 ============================================================================== | |
| 413 7. Dynamic loading *python-dynamic* | |
| 557 | 414 |
| 415 On MS-Windows the Python library can be loaded dynamically. The |:version| | |
| 416 output then includes |+python/dyn|. | |
| 417 | |
| 418 This means that Vim will search for the Python DLL file only when needed. | |
| 419 When you don't use the Python interface you don't need it, thus you can use | |
| 420 Vim without this DLL file. | |
| 421 | |
| 422 To use the Python interface the Python DLL must be in your search path. In a | |
| 423 console window type "path" to see what directories are used. | |
| 424 | |
| 425 The name of the DLL must match the Python version Vim was compiled with. | |
| 426 Currently the name is "python24.dll". That is for Python 2.4. To know for | |
| 427 sure edit "gvim.exe" and search for "python\d*.dll\c". | |
| 428 | |
| 429 ============================================================================== | |
| 3682 | 430 8. Python 3 *python3* |
|
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
431 |
|
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
432 *:py3* *:python3* |
| 3750 | 433 The |:py3| and |:python3| commands work similar to |:python|. A simple check |
| 4098 | 434 if the `:py3` command is working: > |
| 3750 | 435 :py3 print("Hello") |
| 436 < *:py3file* | |
|
2409
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
437 The |:py3file| command works similar to |:pyfile|. |
|
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
438 |
| 3682 | 439 |
|
2409
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
440 Vim can be built in four ways (:version output): |
|
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
441 1. No Python support (-python, -python3) |
|
2409
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
442 2. Python 2 support only (+python or +python/dyn, -python3) |
|
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
443 3. Python 3 support only (-python, +python3 or +python3/dyn) |
|
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
444 4. Python 2 and 3 support (+python/dyn, +python3/dyn) |
|
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
445 |
|
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
446 Some more details on the special case 4: |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
447 |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
448 When Python 2 and Python 3 are both supported they must be loaded dynamically. |
| 2540 | 449 |
|
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
450 When doing this on Linux/Unix systems and importing global symbols, this leads |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
451 to a crash when the second Python version is used. So either global symbols |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
452 are loaded but only one Python version is activated, or no global symbols are |
|
2608
7d8af31066c8
Updated runtime files and translations.
Bram Moolenaar <bram@vim.org>
parents:
2577
diff
changeset
|
453 loaded. The latter makes Python's "import" fail on libraries that expect the |
|
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
454 symbols to be provided by Vim. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
455 *E836* *E837* |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
456 Vim's configuration script makes a guess for all libraries based on one |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
457 standard Python library (termios). If importing this library succeeds for |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
458 both Python versions, then both will be made available in Vim at the same |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
459 time. If not, only the version first used in a session will be enabled. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
460 When trying to use the other one you will get the E836 or E837 error message. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
461 |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
462 Here Vim's behavior depends on the system in which it was configured. In a |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
463 system where both versions of Python were configured with --enable-shared, |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
464 both versions of Python will be activated at the same time. There will still |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
465 be problems with other third party libraries that were not linked to |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
466 libPython. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
467 |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
468 To work around such problems there are these options: |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
469 1. The problematic library is recompiled to link to the according |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
470 libpython.so. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
471 2. Vim is recompiled for only one Python version. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
472 3. You undefine PY_NO_RTLD_GLOBAL in auto/config.h after configuration. This |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
473 may crash Vim though. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
474 |
| 2826 | 475 *has-python* |
| 476 You can test what Python version is available with: > | |
| 477 if has('python') | |
| 3082 | 478 echo 'there is Python 2.x' |
| 2826 | 479 elseif has('python3') |
| 480 echo 'there is Python 3.x' | |
| 481 endif | |
| 482 | |
| 483 Note however, that when Python 2 and 3 are both available and loaded | |
| 484 dynamically, these has() calls will try to load them. If only one can be | |
| 485 loaded at a time, just checking if Python 2 or 3 are available will prevent | |
| 486 the other one from being available. | |
|
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
487 |
|
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
488 ============================================================================== |
| 7 | 489 vim:tw=78:ts=8:ft=help:norl: |