Mercurial > vim
view runtime/doc/diff.txt @ 32936:c517845bd10e v9.0.1776
patch 9.0.1776: No support for stable Python 3 ABI
Commit: https://github.com/vim/vim/commit/c13b3d1350b60b94fe87f0761ea31c0e7fb6ebf3
Author: Yee Cheng Chin <ychin.git@gmail.com>
Date: Sun Aug 20 21:18:38 2023 +0200
patch 9.0.1776: No support for stable Python 3 ABI
Problem: No support for stable Python 3 ABI
Solution: Support Python 3 stable ABI
Commits:
1) Support Python 3 stable ABI to allow mixed version interoperatbility
Vim currently supports embedding Python for use with plugins, and the
"dynamic" linking option allows the user to specify a locally installed
version of Python by setting `pythonthreedll`. However, one caveat is
that the Python 3 libs are not binary compatible across minor versions,
and mixing versions can potentially be dangerous (e.g. let's say Vim was
linked against the Python 3.10 SDK, but the user sets `pythonthreedll`
to a 3.11 lib). Usually, nothing bad happens, but in theory this could
lead to crashes, memory corruption, and other unpredictable behaviors.
It's also difficult for the user to tell something is wrong because Vim
has no way of reporting what Python 3 version Vim was linked with.
For Vim installed via a package manager, this usually isn't an issue
because all the dependencies would already be figured out. For prebuilt
Vim binaries like MacVim (my motivation for working on this), AppImage,
and Win32 installer this could potentially be an issue as usually a
single binary is distributed. This is more tricky when a new Python
version is released, as there's a chicken-and-egg issue with deciding
what Python version to build against and hard to keep in sync when a new
Python version just drops and we have a mix of users of different Python
versions, and a user just blindly upgrading to a new Python could lead to
bad interactions with Vim.
Python 3 does have a solution for this problem: stable ABI / limited API
(see https://docs.python.org/3/c-api/stable.html). The C SDK limits the
API to a set of functions that are promised to be stable across
versions. This pull request adds an ifdef config that allows us to turn
it on when building Vim. Vim binaries built with this option should be
safe to freely link with any Python 3 libraies without having the
constraint of having to use the same minor version.
Note: Python 2 has no such concept and this doesn't change how Python 2
integration works (not that there is going to be a new version of Python
2 that would cause compatibility issues in the future anyway).
---
Technical details:
======
The stable ABI can be accessed when we compile with the Python 3 limited
API (by defining `Py_LIMITED_API`). The Python 3 code (in `if_python3.c`
and `if_py_both.h`) would now handle this and switch to limited API
mode. Without it set, Vim will still use the full API as before so this
is an opt-in change.
The main difference is that `PyType_Object` is now an opaque struct that
we can't directly create "static types" out of, and we have to create
type objects as "heap types" instead. This is because the struct is not
stable and changes from version to version (e.g. 3.8 added a
`tp_vectorcall` field to it). I had to change all the types to be
allocated on the heap instead with just a pointer to them.
Other functions are also simply missing in limited API, or they are
introduced too late (e.g. `PyUnicode_AsUTF8AndSize` in 3.10) to it that
we need some other ways to do the same thing, so I had to abstract a few
things into macros, and sometimes re-implement functions like
`PyObject_NEW`.
One caveat is that in limited API, `OutputType` (used for replacing
`sys.stdout`) no longer inherits from `PyStdPrinter_Type` which I don't
think has any real issue other than minor differences in how they
convert to a string and missing a couple functions like `mode()` and
`fileno()`.
Also fixed an existing bug where `tp_basicsize` was set incorrectly for
`BufferObject`, `TabListObject, `WinListObject`.
Technically, there could be a small performance drop, there is a little
more indirection with accessing type objects, and some APIs like
`PyUnicode_AsUTF8AndSize` are missing, but in practice I didn't see any
difference, and any well-written Python plugin should try to avoid
excessing callbacks to the `vim` module in Python anyway.
I only tested limited API mode down to Python 3.7, which seemes to
compile and work fine. I haven't tried earlier Python versions.
2) Fix PyIter_Check on older Python vers / type##Ptr unused warning
For PyIter_Check, older versions exposed them as either macros (used in
full API), or a function (for use in limited API). A previous change
exposed PyIter_Check to the dynamic build because Python just moved it
to function-only in 3.10 anyway. Because of that, just make sure we
always grab the function in dynamic builds in earlier versions since
that's what Python eventually did anyway.
3) Move Py_LIMITED_API define to configure script
Can now use --with-python-stable-abi flag to customize what stable ABI
version to target. Can also use an env var to do so as well.
4) Show +python/dyn-stable in :version, and allow has() feature query
Not sure if the "/dyn-stable" suffix would break things, or whether we
should do it another way. Or just don't show it in version and rely on
has() feature checking.
5) Documentation first draft. Still need to implement v:python3_version
6) Fix PyIter_Check build breaks when compiling against Python 3.8
7) Add CI coverage stable ABI on Linux/Windows / make configurable on Windows
This adds configurable options for Windows make files (both MinGW and
MSVC). CI will also now exercise both traditional full API and stable
ABI for Linux and Windows in the matrix for coverage.
Also added a "dynamic" option to Linux matrix as a drive-by change to
make other scripting languages like Ruby / Perl testable under both
static and dynamic builds.
8) Fix inaccuracy in Windows docs
Python's own docs are confusing but you don't actually want to use
`python3.dll` for the dynamic linkage.
9) Add generated autoconf file
10) Add v:python3_version support
This variable indicates the version of Python3 that Vim was built
against (PY_VERSION_HEX), and will be useful to check whether the Python
library you are loading in dynamically actually fits it. When built with
stable ABI, it will be the limited ABI version instead
(`Py_LIMITED_API`), which indicates the minimum version of Python 3 the
user should have, rather than the exact match. When stable ABI is used,
we won't be exposing PY_VERSION_HEX in this var because it just doesn't
seem necessary to do so (the whole point of stable ABI is the promise
that it will work across versions), and I don't want to confuse the user
with too many variables.
Also, cleaned up some documentation, and added help tags.
11) Fix Python 3.7 compat issues
Fix a couple issues when using limited API < 3.8
- Crash on exit: In Python 3.7, if a heap-allocated type is destroyed
before all instances are, it would cause a crash later. This happens
when we destroyed `OptionsType` before calling `Py_Finalize` when
using the limited API. To make it worse, later versions changed the
semantics and now each instance has a strong reference to its own type
and the recommendation has changed to have each instance de-ref its
own type and have its type in GC traversal. To avoid dealing with
these cross-version variations, we just don't free the heap type. They
are static types in non-limited-API anyway and are designed to last
through the entirety of the app, and we also don't restart the Python
runtime and therefore do not need it to have absolutely 0 leaks.
See:
- https://docs.python.org/3/whatsnew/3.8.html#changes-in-the-c-api
- https://docs.python.org/3/whatsnew/3.9.html#changes-in-the-c-api
- PyIter_Check: This function is not provided in limited APIs older than
3.8. Previously I was trying to mock it out using manual
PyType_GetSlot() but it was brittle and also does not actually work
properly for static types (it will generate a Python error). Just
return false. It does mean using limited API < 3.8 is not recommended
as you lose the functionality to handle iterators, but from playing
with plugins I couldn't find it to be an issue.
- Fix loading of PyIter_Check so it will be done when limited API < 3.8.
Otherwise loading a 3.7 Python lib will fail even if limited API was
specified to use it.
12) Make sure to only load `PyUnicode_AsUTF8AndSize` in needed in limited API
We don't use this function unless limited API >= 3.10, but we were
loading it regardless. Usually it's ok in Unix-like systems where Python
just has a single lib that we load from, but in Windows where there is a
separate python3.dll this would not work as the symbol would not have
been exposed in this more limited DLL file. This makes it much clearer
under what condition is this function needed.
closes: #12032
Signed-off-by: Christian Brabandt <cb@256bit.org>
Co-authored-by: Yee Cheng Chin <ychin.git@gmail.com>
author | Christian Brabandt <cb@256bit.org> |
---|---|
date | Sun, 20 Aug 2023 21:30:04 +0200 |
parents | b2e8663e6dcc |
children | 4635e43f2c6f |
line wrap: on
line source
*diff.txt* For Vim version 9.0. Last change: 2023 Apr 04 VIM REFERENCE MANUAL by Bram Moolenaar *diff* *vimdiff* *gvimdiff* *diff-mode* This file describes the |+diff| feature: Showing differences between two to eight versions of the same file. The basics are explained in section |08.7| of the user manual. 1. Starting diff mode |start-vimdiff| 2. Viewing diffs |view-diffs| 3. Jumping to diffs |jumpto-diffs| 4. Copying diffs |copy-diffs| 5. Diff options |diff-options| ============================================================================== 1. Starting diff mode *start-vimdiff* The easiest way to start editing in diff mode is with the "vimdiff" command. This starts Vim as usual, and additionally sets up for viewing the differences between the arguments. > vimdiff file1 file2 [file3 [file4]] This is equivalent to: > vim -d file1 file2 [file3 [file4]] You may also use "gvimdiff" or "vim -d -g". The GUI is started then. You may also use "viewdiff" or "gviewdiff". Vim starts in readonly mode then. "r" may be prepended for restricted mode (see |-Z|). The second and following arguments may also be a directory name. Vim will then append the file name of the first argument to the directory name to find the file. By default an internal diff library will be used. When 'diffopt' or 'diffexpr' has been set an external "diff" command will be used. This only works when such a diff program is available. Diffs are local to the current tab page |tab-page|. You can't see diffs with a window in another tab page. This does make it possible to have several diffs at the same time, each in their own tab page. What happens is that Vim opens a window for each of the files. This is like using the |-O| argument. This uses vertical splits. If you prefer horizontal splits add the |-o| argument: > vimdiff -o file1 file2 [file3 [file4]] If you always prefer horizontal splits include "horizontal" in 'diffopt'. In each of the edited files these options are set: 'diff' on 'scrollbind' on 'cursorbind' on 'scrollopt' includes "hor" 'wrap' off, or leave as-is if 'diffopt' includes "followwrap" 'foldmethod' "diff" 'foldcolumn' value from 'diffopt', default is 2 These options are set local to the window. When editing another file they are reset to the global value. The options can still be overruled from a modeline when re-editing the file. However, 'foldmethod' and 'wrap' won't be set from a modeline when 'diff' is set. See `:diffoff` for an easy way to revert the options. The differences shown are actually the differences in the buffer. Thus if you make changes after loading a file, these will be included in the displayed diffs. You might have to do ":diffupdate" now and then, not all changes are immediately taken into account, especially when using an external diff command. In your .vimrc file you could do something special when Vim was started in diff mode. You could use a construct like this: > if &diff setup for diff mode else setup for non-diff mode endif While already in Vim you can start diff mode in three ways. *E98* :diffs[plit] {filename} *:diffs* *:diffsplit* Open a new window on the file {filename}. The options are set as for "vimdiff" for the current and the newly opened window. Also see 'diffexpr'. *:difft* *:diffthis* :difft[his] Make the current window part of the diff windows. This sets the options like for "vimdiff". :diffp[atch] {patchfile} *E816* *:diffp* *:diffpatch* Use the current buffer, patch it with the diff found in {patchfile} and open a buffer on the result. The options are set as for "vimdiff". {patchfile} can be in any format that the "patch" program understands or 'patchexpr' can handle. Note that {patchfile} should only contain a diff for one file, the current file. If {patchfile} contains diffs for other files as well, the results are unpredictable. Vim changes directory to /tmp to avoid files in the current directory accidentally being patched. But it may still result in various ".rej" files to be created. And when absolute path names are present these files may get patched anyway. Using the "patch" command is not allowed in |restricted-mode|. To make these commands use a vertical split, prepend |:vertical|. Examples: > :vert diffsplit main.c~ :vert diffpatch /tmp/diff If you always prefer a vertical split include "vertical" in 'diffopt'. *E96* There can be up to eight buffers with 'diff' set. Since the option values are remembered with the buffer, you can edit another file for a moment and come back to the same file and be in diff mode again. *:diffo* *:diffoff* :diffo[ff] Switch off diff mode for the current window. Resets related options also when 'diff' was not set. :diffo[ff]! Switch off diff mode for the current window and in all windows in the current tab page where 'diff' is set. Resetting related options only happens in a window that has 'diff' set, if the current window does not have 'diff' set then no options in it are changed. Hidden buffers are also removed from the list of diff'ed buffers. The `:diffoff` command resets the relevant options to the values they had when using `:diffsplit`, `:diffpatch`, `:diffthis`. or starting Vim in diff mode. When using `:diffoff` twice the last saved values are restored. Otherwise they are set to their default value: 'diff' off 'scrollbind' off 'cursorbind' off 'scrollopt' without "hor" 'wrap' on, or leave as-is if 'diffopt' includes "followwrap" 'foldmethod' "manual" 'foldcolumn' 0 'foldenable' will most-likely be reset to off. That is when 'foldmethod' is is restored to "manual". The folds themselves are not cleared but they should not show up, resetting 'foldenable' is the best way to do that. ============================================================================== 2. Viewing diffs *view-diffs* The effect is that the diff windows show the same text, with the differences highlighted. When scrolling the text, the 'scrollbind' option will make the text in other windows to be scrolled as well. With vertical splits the text should be aligned properly. The alignment of text will go wrong when: - 'wrap' is on, some lines will be wrapped and occupy two or more screen lines - folds are open in one window but not another - 'scrollbind' is off - changes have been made to the text - "filler" is not present in 'diffopt', deleted/inserted lines makes the alignment go wrong All the buffers edited in a window where the 'diff' option is set will join in the diff. This is also possible for hidden buffers. They must have been edited in a window first for this to be possible. To get rid of the hidden buffers use `:diffoff!`. *:DiffOrig* *diff-original-file* Since 'diff' is a window-local option, it's possible to view the same buffer in diff mode in one window and "normal" in another window. It is also possible to view the changes you have made to a buffer since the file was loaded. Since Vim doesn't allow having two buffers for the same file, you need another buffer. This command is useful: > command DiffOrig vert new | set bt=nofile | r ++edit # | 0d_ \ | diffthis | wincmd p | diffthis (this is in |defaults.vim|). Use ":DiffOrig" to see the differences between the current buffer and the file it was loaded from. A buffer that is unloaded cannot be used for the diff. But it does work for hidden buffers. You can use ":hide" to close a window without unloading the buffer. If you don't want a buffer to remain used for the diff do ":set nodiff" before hiding it. *:dif* *:diff* *:diffupdate* :dif[fupdate][!] Update the diff highlighting and folds. Vim attempts to keep the differences updated when you make changes to the text. This mostly takes care of inserted and deleted lines. Changes within a line and more complicated changes do not cause the differences to be updated. To force the differences to be updated use: > :diffupdate If the ! is included Vim will check if the file was changed externally and needs to be reloaded. It will prompt for each changed file, like `:checktime` was used. Vim will show filler lines for lines that are missing in one window but are present in another. These lines were inserted in another file or deleted in this file. Removing "filler" from the 'diffopt' option will make Vim not display these filler lines. Folds are used to hide the text that wasn't changed. See |folding| for all the commands that can be used with folds. The context of lines above a difference that are not included in the fold can be set with the 'diffopt' option. For example, to set the context to three lines: > :set diffopt=filler,context:3 The diffs are highlighted with these groups: |hl-DiffAdd| DiffAdd Added (inserted) lines. These lines exist in this buffer but not in another. |hl-DiffChange| DiffChange Changed lines. |hl-DiffText| DiffText Changed text inside a Changed line. Vim finds the first character that is different, and the last character that is different (searching from the end of the line). The text in between is highlighted. This means that parts in the middle that are still the same are highlighted anyway. The 'diffopt' flags "iwhite" and "icase" are used here. |hl-DiffDelete| DiffDelete Deleted lines. Also called filler lines, because they don't really exist in this buffer. ============================================================================== 3. Jumping to diffs *jumpto-diffs* Two commands can be used to jump to diffs: *[c* [c Jump backwards to the previous start of a change. When a count is used, do it that many times. *]c* ]c Jump forwards to the next start of a change. When a count is used, do it that many times. It is an error if there is no change for the cursor to move to. ============================================================================== 4. Diff copying *copy-diffs* *E99* *E100* *E101* *E102* *E103* *merge* There are two commands to copy text from one buffer to another. The result is that the buffers will be equal within the specified range. *:diffg* *:diffget* :[range]diffg[et] [bufspec] Modify the current buffer to undo difference with another buffer. If [bufspec] is given, that buffer is used. If [bufspec] refers to the current buffer then nothing happens. Otherwise this only works if there is one other buffer in diff mode. See below for [range]. *:diffpu* *:diffput* *E793* :[range]diffpu[t] [bufspec] Modify another buffer to undo difference with the current buffer. Just like ":diffget" but the other buffer is modified instead of the current one. When [bufspec] is omitted and there is more than one other buffer in diff mode where 'modifiable' is set this fails. See below for [range]. *do* [count]do Same as ":diffget" without range. The "o" stands for "obtain" ("dg" can't be used, it could be the start of "dgg"!). Note: this doesn't work in Visual mode. If you give a [count], it is used as the [bufspec] argument for ":diffget". *dp* [count]dp Same as ":diffput" without range. Note: this doesn't work in Visual mode. If you give a [count], it is used as the [bufspec] argument for ":diffput". When no [range] is given, the diff at the cursor position or just above it is affected. When [range] is used, Vim tries to only put or get the specified lines. When there are deleted lines, this may not always be possible. There can be deleted lines below the last line of the buffer. When the cursor is on the last line in the buffer and there is no diff above this line, the ":diffget" and "do" commands will obtain lines from the other buffer. To be able to get those lines from another buffer in a [range] it's allowed to use the last line number plus one. This command gets all diffs from the other buffer: > :1,$+1diffget Note that deleted lines are displayed, but not counted as text lines. You can't move the cursor into them. To fill the deleted lines with the lines from another buffer use ":diffget" on the line below them. *E787* When the buffer that is about to be modified is read-only and the autocommand that is triggered by |FileChangedRO| changes buffers the command will fail. The autocommand must not change buffers. The [bufspec] argument above can be a buffer number, a pattern for a buffer name or a part of a buffer name. Examples: :diffget Use the other buffer which is in diff mode :diffget 3 Use buffer 3 :diffget v2 Use the buffer which matches "v2" and is in diff mode (e.g., "file.c.v2") ============================================================================== 5. Diff options *diff-options* Also see |'diffopt'| and the "diff" item of |'fillchars'|. *diff-slow* *diff_translations* For very long lines, the diff syntax highlighting might be slow, especially since it tries to match all different kind of localisations. To disable localisations and speed up the syntax highlighting, set the global variable g:diff_translations to zero: > let g:diff_translations = 0 < After setting this variable, reload the syntax script: > set syntax=diff < FINDING THE DIFFERENCES *diff-diffexpr* The 'diffexpr' option can be set to use something else than the internal diff support or the standard "diff" program to compare two files and find the differences. *E959* When 'diffexpr' is empty, Vim uses this command to find the differences between file1 and file2: > diff file1 file2 > outfile The ">" is replaced with the value of 'shellredir'. The output of "diff" must be a normal "ed" style diff or a unified diff. A context diff will NOT work. For a unified diff no context lines can be used. Using "diff -u" will NOT work, use "diff -U0". This example explains the format that Vim expects for the "ed" style diff: > 1a2 > bbb 4d4 < 111 7c7 < GGG --- > ggg The "1a2" item appends the line "bbb". The "4d4" item deletes the line "111". The "7c7" item replaces the line "GGG" with "ggg". When 'diffexpr' is not empty, Vim evaluates it to obtain a diff file in the format mentioned. These variables are set to the file names used: v:fname_in original file v:fname_new new version of the same file v:fname_out where to write the resulting diff file Additionally, 'diffexpr' should take care of "icase" and "iwhite" in the 'diffopt' option. 'diffexpr' cannot change the value of 'lines' and 'columns'. The advantage of using a function call without arguments is that it is faster, see |expr-option-function|. Example (this does almost the same as 'diffexpr' being empty): > set diffexpr=MyDiff() function MyDiff() let opt = "" if &diffopt =~ "icase" let opt = opt .. "-i " endif if &diffopt =~ "iwhite" let opt = opt .. "-b " endif silent execute "!diff -a --binary " .. opt .. v:fname_in .. " " .. v:fname_new .. \ " > " .. v:fname_out redraw! endfunction The "-a" argument is used to force comparing the files as text, comparing as binaries isn't useful. The "--binary" argument makes the files read in binary mode, so that a CTRL-Z doesn't end the text on DOS. The `redraw!` command may not be needed, depending on whether executing a shell command shows something on the display or not. If the 'diffexpr' expression starts with s: or |<SID>|, then it is replaced with the script ID (|local-function|). Example: > set diffexpr=s:MyDiffExpr() set diffexpr=<SID>SomeDiffExpr() Otherwise, the expression is evaluated in the context of the script where the option was set, thus script-local items are available. *E810* *E97* Vim will do a test if the diff output looks alright. If it doesn't, you will get an error message. Possible causes: - The "diff" program cannot be executed. - The "diff" program doesn't produce normal "ed" style diffs (see above). - The 'shell' and associated options are not set correctly. Try if filtering works with a command like ":!sort". - You are using 'diffexpr' and it doesn't work. If it's not clear what the problem is set the 'verbose' option to one or more to see more messages. The self-installing Vim for MS-Windows includes a diff program. If you don't have it you might want to download a diff.exe. For example from http://gnuwin32.sourceforge.net/packages/diffutils.htm. USING PATCHES *diff-patchexpr* The 'patchexpr' option can be set to use something else than the standard "patch" program. When 'patchexpr' is empty, Vim will call the "patch" program like this: > patch -o outfile origfile < patchfile This should work fine with most versions of the "patch" program. Note that a CR in the middle of a line may cause problems, it is seen as a line break. If the default doesn't work for you, set the 'patchexpr' to an expression that will have the same effect. These variables are set to the file names used: v:fname_in original file v:fname_diff patch file v:fname_out resulting patched file The advantage of using a function call without arguments is that it is faster, see |expr-option-function|. Example (this does the same as 'patchexpr' being empty): > set patchexpr=MyPatch() function MyPatch() :call system("patch -o " .. v:fname_out .. " " .. v:fname_in .. \ " < " .. v:fname_diff) endfunction Make sure that using the "patch" program doesn't have unwanted side effects. For example, watch out for additionally generated files, which should be deleted. It should just patch the file and nothing else. Vim will change directory to "/tmp" or another temp directory before evaluating 'patchexpr'. This hopefully avoids that files in the current directory are accidentally patched. Vim will also delete files starting with v:fname_in and ending in ".rej" and ".orig". If the 'patchexpr' expression starts with s: or |<SID>|, then it is replaced with the script ID (|local-function|). Example: > set patchexpr=s:MyPatchExpr() set patchexpr=<SID>SomePatchExpr() Otherwise, the expression is evaluated in the context of the script where the option was set, thus script-local items are available. vim:tw=78:ts=8:noet:ft=help:norl: