To: vim_dev@googlegroups.com
Subject: Patch 7.3.1163
Fcc: outbox
From: Bram Moolenaar <Bram@moolenaar.net>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
------------
 
Patch 7.3.1163
Problem:    Not easy to load Python modules.
Solution:   Search "python2", "python3" and "pythonx" directories in
	    'runtimepath' for Python modules. (ZyX)
Files:	    runtime/doc/if_pyth.txt, src/configure.in, src/ex_cmds2.c,
	    src/if_py_both.h, src/if_python.c, src/if_python3.c,
	    src/testdir/test86.in, src/testdir/test87.in, src/auto/configure
 
 
*** ../vim-7.3.1162/runtime/doc/if_pyth.txt	2013-06-02 18:20:12.000000000 +0200
--- runtime/doc/if_pyth.txt	2013-06-10 20:51:21.000000000 +0200
***************
*** 180,185 ****
--- 180,191 ----
  	Like |strwidth()|: returns number of display cells str occupies, tab 
  	is counted as one cell.
  
+ vim.foreach_rtp(callable)				*python-foreach_rtp*
+ 	Call the given callable for each path in 'runtimepath' until either 
+ 	callable returns something but None, the exception is raised or there 
+ 	are no longer paths. If stopped in case callable returned non-None, 
+ 	vim.foreach_rtp function returns the value returned by callable.
+ 
  vim.chdir(*args, **kwargs)				*python-chdir*
  vim.fchdir(*args, **kwargs)				*python-fchdir*
  	Run os.chdir or os.fchdir, then all appropriate vim stuff.
***************
*** 300,305 ****
--- 306,418 ----
  	supported, and may cause the program to crash.  This should probably be
  	fixed.
  
+ 		    *python2-directory* *python3-directory* *pythonx-directory*
+ Python 'runtimepath' handling				*python-special-path*
+ 
+ In python vim.VIM_SPECIAL_PATH special directory is used as a replacement for 
+ the list of paths found in 'runtimepath': with this directory in sys.path and 
+ vim.path_hooks in sys.path_hooks python will try to load module from 
+ {rtp}/python2 (or python3) and {rtp}/pythonx (for both python versions) for 
+ each {rtp} found in 'runtimepath'.
+ 
+ Implementation for python 2 is the following: usual importing code with empty 
+ lists in place of sys.path_hooks and sys.meta_path. Code is similar to the 
+ below, but written in C: >
+ 
+     # Assuming vim variable is already accessible and is set to the current 
+     # module
+     import sys
+ 
+     def find_module(fullname):
+         return vim
+ 
+     def load_module(fullname):
+         # see vim._get_paths below
+         new_path = _get_paths()
+ 
+         try:         old_path = sys.path
+         except: pass
+         try:         old_meta_path = sys.meta_path
+         except: pass
+         try:         old_path_hooks = sys.path_hooks
+         except: pass
+ 
+         sys.meta_path = []
+         sys.path_hooks = sys.meta_path
+         sys.path = new_path
+ 
+         try:
+             exec ('import ' + fullname + ' as m')  # No actual exec in C code
+             return m
+         finally:
+             e = None
+             try:                        sys.path = old_path
+             except Exception as e: pass
+             try:                        sys.meta_path = old_meta_path
+             except Exception as e: pass
+             try:                        sys.path_hooks = old_path_hooks
+             except Exception as e: pass
+             if e:
+                 raise e
+ 
+     def path_hook(d):
+         if d == VIM_SPECIAL_PATH:
+             return vim
+         raise ImportError
+ 
+     sys.path_hooks.append(path_hook)
+ 
+ Implementation for python 3 is cleaner: code is similar to the following, but, 
+ again, written in C: >
+ 
+     from importlib.machinery import PathFinder
+     import sys
+ 
+     class Finder(PathFinder):
+         @classmethod
+         def find_module(cls, fullname):
+             # see vim._get_paths below
+             new_path = _get_paths()
+ 
+             # super().find_module is also a class method
+             # super() is not used because this variant is easier to implement 
+             # in C
+             return PathFinder.find_module(fullname, new_path)
+ 
+     def path_hook(path):
+         if path == VIM_SPECIAL_PATH:
+             return Finder
+         raise ImportError
+ 
+     sys.path_hooks.append(path_hook)
+ 
+ vim.VIM_SPECIAL_PATH					*python-VIM_SPECIAL_PATH*
+ 	String constant used in conjunction with vim path hook. If path hook 
+ 	installed by vim is requested to handle anything but path equal to 
+ 	vim.VIM_SPECIAL_PATH constant it raises ImportError. In the only other 
+ 	case it uses special loader.
+ 
+ 	Note: you must not use value of this constant directly, always use 
+ 	      vim.VIM_SPECIAL_PATH object.
+ 
+ vim.load_module(name)					*python-load_module*
+ vim.find_module(...)					*python-find_module*
+ vim.path_hook(path)					*python-path_hook*
+ 	Methods or objects used to implement path loading as described above. 
+ 	You should not be using any of these directly except for vim.path_hook 
+ 	in case you need to do something with sys.meta_path. It is not 
+ 	guaranteed that any of the objects will exist in the future vim 
+ 	versions. In fact, load_module and find_module methods do not exists 
+ 	in python3.
+ 
+ vim._get_paths						*python-_get_paths*
+ 	Methods returning a list of paths which will be searched for by path 
+ 	hook. You should not rely on this method being present in future 
+ 	versions, but can use it for debugging.
+ 
+ 	It returns a list of {rtp}/python2 (or {rtp}/python3) and 
+ 	{rtp}/pythonx directories for each {rtp} in 'runtimepath'.
+ 
  ==============================================================================
  3. Buffer objects					*python-buffer*
  
***************
*** 340,346 ****
  			|BufFilePost| autocommands are launched.
  	b.number	Buffer number. Can be used as |python-buffers| key.
  			Read-only.
! 	b.valid		True or False. Buffer object becames invalid when 
  			corresponding buffer is wiped out.
  
  The buffer object methods are:
--- 453,459 ----
  			|BufFilePost| autocommands are launched.
  	b.number	Buffer number. Can be used as |python-buffers| key.
  			Read-only.
! 	b.valid		True or False. Buffer object becomes invalid when 
  			corresponding buffer is wiped out.
  
  The buffer object methods are:
***************
*** 446,452 ****
  	row, col (read-only)	On-screen window position in display cells.
  				First position is zero.
  	tabpage (read-only)	Window tab page.
! 	valid (read-write)	True or False. Window object becames invalid 
  				when corresponding window is closed.
  
  The height attribute is writable only if the screen is split horizontally.
--- 559,565 ----
  	row, col (read-only)	On-screen window position in display cells.
  				First position is zero.
  	tabpage (read-only)	Window tab page.
! 	valid (read-write)	True or False. Window object becomes invalid 
  				when corresponding window is closed.
  
  The height attribute is writable only if the screen is split horizontally.
***************
*** 471,477 ****
  	windows		Like |python-windows|, but for current tab page.
  	vars		The tab page |t:| variables.
  	window		Current tabpage window.
! 	valid		True or False. Tab page object becames invalid when 
  			corresponding tab page is closed.
  
  TabPage object type is available using "TabPage" attribute of vim module.
--- 584,590 ----
  	windows		Like |python-windows|, but for current tab page.
  	vars		The tab page |t:| variables.
  	window		Current tabpage window.
! 	valid		True or False. Tab page object becomes invalid when 
  			corresponding tab page is closed.
  
  TabPage object type is available using "TabPage" attribute of vim module.
*** ../vim-7.3.1162/src/configure.in	2013-06-02 19:14:11.000000000 +0200
--- src/configure.in	2013-06-10 20:51:21.000000000 +0200
***************
*** 863,872 ****
  	    ${vi_cv_path_python} -c 'import sys; print sys.version[:3]'`
      ]])
  
!     dnl -- it must be at least version 2.2
!     AC_MSG_CHECKING(Python is 2.2 or better)
      if ${vi_cv_path_python} -c \
! 	"import sys; sys.exit(${vi_cv_var_python_version} < 2.2)"
      then
        AC_MSG_RESULT(yep)
  
--- 863,872 ----
  	    ${vi_cv_path_python} -c 'import sys; print sys.version[:3]'`
      ]])
  
!     dnl -- it must be at least version 2.3
!     AC_MSG_CHECKING(Python is 2.3 or better)
      if ${vi_cv_path_python} -c \
! 	"import sys; sys.exit(${vi_cv_var_python_version} < 2.3)"
      then
        AC_MSG_RESULT(yep)
  
*** ../vim-7.3.1162/src/ex_cmds2.c	2013-06-10 20:10:40.000000000 +0200
--- src/ex_cmds2.c	2013-06-10 20:51:21.000000000 +0200
***************
*** 2737,2742 ****
--- 2737,2746 ----
   * When "all" is TRUE repeat for all matches, otherwise only the first one is
   * used.
   * Returns OK when at least one match found, FAIL otherwise.
+  *
+  * If "name" is NULL calls callback for each entry in runtimepath. Cookie is 
+  * passed by reference in this case, setting it to NULL indicates that callback 
+  * has done its job.
   */
      int
  do_in_runtimepath(name, all, callback, cookie)
***************
*** 2768,2774 ****
      buf = alloc(MAXPATHL);
      if (buf != NULL && rtp_copy != NULL)
      {
! 	if (p_verbose > 1)
  	{
  	    verbose_enter();
  	    smsg((char_u *)_("Searching for \"%s\" in \"%s\""),
--- 2772,2778 ----
      buf = alloc(MAXPATHL);
      if (buf != NULL && rtp_copy != NULL)
      {
! 	if (p_verbose > 1 && name != NULL)
  	{
  	    verbose_enter();
  	    smsg((char_u *)_("Searching for \"%s\" in \"%s\""),
***************
*** 2782,2788 ****
  	{
  	    /* Copy the path from 'runtimepath' to buf[]. */
  	    copy_option_part(&rtp, buf, MAXPATHL, ",");
! 	    if (STRLEN(buf) + STRLEN(name) + 2 < MAXPATHL)
  	    {
  		add_pathsep(buf);
  		tail = buf + STRLEN(buf);
--- 2786,2798 ----
  	{
  	    /* Copy the path from 'runtimepath' to buf[]. */
  	    copy_option_part(&rtp, buf, MAXPATHL, ",");
! 	    if (name == NULL)
! 	    {
! 		(*callback)(buf, (void *) &cookie);
! 		if (!did_one)
! 		    did_one = (cookie == NULL);
! 	    }
! 	    else if (STRLEN(buf) + STRLEN(name) + 2 < MAXPATHL)
  	    {
  		add_pathsep(buf);
  		tail = buf + STRLEN(buf);
***************
*** 2821,2827 ****
      }
      vim_free(buf);
      vim_free(rtp_copy);
!     if (p_verbose > 0 && !did_one)
      {
  	verbose_enter();
  	smsg((char_u *)_("not found in 'runtimepath': \"%s\""), name);
--- 2831,2837 ----
      }
      vim_free(buf);
      vim_free(rtp_copy);
!     if (p_verbose > 0 && !did_one && name != NULL)
      {
  	verbose_enter();
  	smsg((char_u *)_("not found in 'runtimepath': \"%s\""), name);
*** ../vim-7.3.1162/src/if_py_both.h	2013-06-10 20:47:33.000000000 +0200
--- src/if_py_both.h	2013-06-10 20:55:17.000000000 +0200
***************
*** 24,29 ****
--- 24,31 ----
  #endif
  #define DOPY_FUNC "_vim_pydo"
  
+ static const char *vim_special_path = "_vim_path_";
+ 
  #define PyErr_SetVim(str) PyErr_SetString(VimError, str)
  
  #define RAISE_NO_EMPTY_KEYS PyErr_SetString(PyExc_ValueError, \
***************
*** 55,60 ****
--- 57,64 ----
  static PyObject *py_chdir;
  static PyObject *py_fchdir;
  static PyObject *py_getcwd;
+ static PyObject *vim_module;
+ static PyObject *vim_special_path_object;
  
  /*
   * obtain a lock on the Vim data structures
***************
*** 779,797 ****
      return _VimChdir(py_fchdir, args, kwargs);
  }
  
  /*
   * Vim module - Definitions
   */
  
  static struct PyMethodDef VimMethods[] = {
!     /* name,	     function,			calling,			documentation */
!     {"command",	     VimCommand,		METH_VARARGS,			"Execute a Vim ex-mode command" },
!     {"eval",	     VimEval,			METH_VARARGS,			"Evaluate an expression using Vim evaluator" },
!     {"bindeval",     VimEvalPy,			METH_VARARGS,			"Like eval(), but returns objects attached to vim ones"},
!     {"strwidth",     VimStrwidth,		METH_VARARGS,			"Screen string width, counts <Tab> as having width 1"},
!     {"chdir",	     (PyCFunction)VimChdir,	METH_VARARGS|METH_KEYWORDS,	"Change directory"},
!     {"fchdir",	     (PyCFunction)VimFchdir,	METH_VARARGS|METH_KEYWORDS,	"Change directory"},
!     { NULL,	     NULL,			0,				NULL }
  };
  
  /*
--- 783,950 ----
      return _VimChdir(py_fchdir, args, kwargs);
  }
  
+ typedef struct {
+     PyObject	*callable;
+     PyObject	*result;
+ } map_rtp_data;
+ 
+     static void
+ map_rtp_callback(char_u *path, void *_data)
+ {
+     void	**data = (void **) _data;
+     PyObject	*pathObject;
+     map_rtp_data	*mr_data = *((map_rtp_data **) data);
+ 
+     if (!(pathObject = PyString_FromString((char *) path)))
+     {
+ 	*data = NULL;
+ 	return;
+     }
+ 
+     mr_data->result = PyObject_CallFunctionObjArgs(mr_data->callable,
+ 						   pathObject, NULL);
+ 
+     Py_DECREF(pathObject);
+ 
+     if (!mr_data->result || mr_data->result != Py_None)
+ 	*data = NULL;
+     else
+     {
+ 	Py_DECREF(mr_data->result);
+ 	mr_data->result = NULL;
+     }
+ }
+ 
+     static PyObject *
+ VimForeachRTP(PyObject *self UNUSED, PyObject *args)
+ {
+     map_rtp_data	data;
+ 
+     if (!PyArg_ParseTuple(args, "O", &data.callable))
+ 	return NULL;
+ 
+     data.result = NULL;
+ 
+     do_in_runtimepath(NULL, FALSE, &map_rtp_callback, &data);
+ 
+     if (data.result == NULL)
+     {
+ 	if (PyErr_Occurred())
+ 	    return NULL;
+ 	else
+ 	{
+ 	    Py_INCREF(Py_None);
+ 	    return Py_None;
+ 	}
+     }
+     return data.result;
+ }
+ 
+ /*
+  * _vim_runtimepath_ special path implementation.
+  */
+ 
+     static void
+ map_finder_callback(char_u *path, void *_data)
+ {
+     void	**data = (void **) _data;
+     PyObject	*list = *((PyObject **) data);
+     PyObject	*pathObject1, *pathObject2;
+     char	*pathbuf;
+     size_t	pathlen;
+ 
+     pathlen = STRLEN(path);
+ 
+ #if PY_MAJOR_VERSION < 3
+ # define PY_MAIN_DIR_STRING "python2"
+ #else
+ # define PY_MAIN_DIR_STRING "python3"
+ #endif
+ #define PY_ALTERNATE_DIR_STRING "pythonx"
+ 
+ #define PYTHONX_STRING_LENGTH 7 /* STRLEN("pythonx") */
+     if (!(pathbuf = PyMem_New(char,
+ 		    pathlen + STRLEN(PATHSEPSTR) + PYTHONX_STRING_LENGTH + 1)))
+     {
+ 	PyErr_NoMemory();
+ 	*data = NULL;
+ 	return;
+     }
+ 
+     mch_memmove(pathbuf, path, pathlen + 1);
+     add_pathsep((char_u *) pathbuf);
+ 
+     pathlen = STRLEN(pathbuf);
+     mch_memmove(pathbuf + pathlen, PY_MAIN_DIR_STRING,
+ 	    PYTHONX_STRING_LENGTH + 1);
+ 
+     if (!(pathObject1 = PyString_FromString(pathbuf)))
+     {
+ 	*data = NULL;
+ 	PyMem_Free(pathbuf);
+ 	return;
+     }
+ 
+     mch_memmove(pathbuf + pathlen, PY_ALTERNATE_DIR_STRING,
+ 	    PYTHONX_STRING_LENGTH + 1);
+ 
+     if (!(pathObject2 = PyString_FromString(pathbuf)))
+     {
+ 	Py_DECREF(pathObject1);
+ 	PyMem_Free(pathbuf);
+ 	*data = NULL;
+ 	return;
+     }
+ 
+     PyMem_Free(pathbuf);
+ 
+     if (PyList_Append(list, pathObject1)
+ 	    || PyList_Append(list, pathObject2))
+ 	*data = NULL;
+ 
+     Py_DECREF(pathObject1);
+     Py_DECREF(pathObject2);
+ }
+ 
+     static PyObject *
+ Vim_GetPaths(PyObject *self UNUSED)
+ {
+     PyObject	*r;
+ 
+     if (!(r = PyList_New(0)))
+ 	return NULL;
+ 
+     do_in_runtimepath(NULL, FALSE, &map_finder_callback, r);
+ 
+     if (PyErr_Occurred())
+     {
+ 	Py_DECREF(r);
+ 	return NULL;
+     }
+ 
+     return r;
+ }
+ 
  /*
   * Vim module - Definitions
   */
  
  static struct PyMethodDef VimMethods[] = {
!     /* name,	    function,			calling,			documentation */
!     {"command",	    VimCommand,			METH_VARARGS,			"Execute a Vim ex-mode command" },
!     {"eval",	    VimEval,			METH_VARARGS,			"Evaluate an expression using Vim evaluator" },
!     {"bindeval",    VimEvalPy,			METH_VARARGS,			"Like eval(), but returns objects attached to vim ones"},
!     {"strwidth",    VimStrwidth,		METH_VARARGS,			"Screen string width, counts <Tab> as having width 1"},
!     {"chdir",	    (PyCFunction)VimChdir,	METH_VARARGS|METH_KEYWORDS,	"Change directory"},
!     {"fchdir",	    (PyCFunction)VimFchdir,	METH_VARARGS|METH_KEYWORDS,	"Change directory"},
!     {"foreach_rtp", VimForeachRTP,		METH_VARARGS,			"Call given callable for each path in &rtp"},
! #if PY_MAJOR_VERSION < 3
!     {"find_module", FinderFindModule,		METH_VARARGS,			"Internal use only, returns loader object for any input it receives"},
!     {"load_module", LoaderLoadModule,		METH_VARARGS,			"Internal use only, tries importing the given module from &rtp by temporary mocking sys.path (to an rtp-based one) and unsetting sys.meta_path and sys.path_hooks"},
! #endif
!     {"path_hook",   VimPathHook,		METH_VARARGS,			"Hook function to install in sys.path_hooks"},
!     {"_get_paths",  (PyCFunction)Vim_GetPaths,	METH_NOARGS,			"Get &rtp-based additions to sys.path"},
!     { NULL,	    NULL,			0,				NULL}
  };
  
  /*
***************
*** 5036,5041 ****
--- 5189,5202 ----
  } CurrentObject;
  static PyTypeObject CurrentType;
  
+ #if PY_MAJOR_VERSION >= 3
+ typedef struct
+ {
+     PyObject_HEAD
+ } FinderObject;
+ static PyTypeObject FinderType;
+ #endif
+ 
      static void
  init_structs(void)
  {
***************
*** 5281,5286 ****
--- 5442,5522 ----
      PYTYPE_READY(FunctionType);
      PYTYPE_READY(OptionsType);
      PYTYPE_READY(OutputType);
+ #if PY_MAJOR_VERSION >= 3
+     PYTYPE_READY(FinderType);
+ #endif
+     return 0;
+ }
+ 
+     static int
+ init_sys_path()
+ {
+     PyObject	*path;
+     PyObject	*path_hook;
+     PyObject	*path_hooks;
+ 
+     if (!(path_hook = PyObject_GetAttrString(vim_module, "path_hook")))
+ 	return -1;
+ 
+     if (!(path_hooks = PySys_GetObject("path_hooks")))
+     {
+ 	PyErr_Clear();
+ 	path_hooks = PyList_New(1);
+ 	PyList_SET_ITEM(path_hooks, 0, path_hook);
+ 	if (PySys_SetObject("path_hooks", path_hooks))
+ 	{
+ 	    Py_DECREF(path_hooks);
+ 	    return -1;
+ 	}
+ 	Py_DECREF(path_hooks);
+     }
+     else if (PyList_Check(path_hooks))
+     {
+ 	if (PyList_Append(path_hooks, path_hook))
+ 	{
+ 	    Py_DECREF(path_hook);
+ 	    return -1;
+ 	}
+ 	Py_DECREF(path_hook);
+     }
+     else
+     {
+ 	VimTryStart();
+ 	EMSG(_("Failed to set path hook: sys.path_hooks is not a list\n"
+ 	       "You should now do the following:\n"
+ 	       "- append vim.path_hook to sys.path_hooks\n"
+ 	       "- append vim.VIM_SPECIAL_PATH to sys.path\n"));
+ 	VimTryEnd(); /* Discard the error */
+ 	Py_DECREF(path_hook);
+ 	return 0;
+     }
+ 
+     if (!(path = PySys_GetObject("path")))
+     {
+ 	PyErr_Clear();
+ 	path = PyList_New(1);
+ 	Py_INCREF(vim_special_path_object);
+ 	PyList_SET_ITEM(path, 0, vim_special_path_object);
+ 	if (PySys_SetObject("path", path))
+ 	{
+ 	    Py_DECREF(path);
+ 	    return -1;
+ 	}
+ 	Py_DECREF(path);
+     }
+     else if (PyList_Check(path))
+     {
+ 	if (PyList_Append(path, vim_special_path_object))
+ 	    return -1;
+     }
+     else
+     {
+ 	VimTryStart();
+ 	EMSG(_("Failed to set path: sys.path is not a list\n"
+ 	       "You should now append vim.VIM_SPECIAL_PATH to sys.path"));
+ 	VimTryEnd(); /* Discard the error */
+     }
+ 
      return 0;
  }
  
***************
*** 5332,5337 ****
--- 5568,5576 ----
      {"List",       (PyObject *)&ListType},
      {"Function",   (PyObject *)&FunctionType},
      {"Options",    (PyObject *)&OptionsType},
+ #if PY_MAJOR_VERSION >= 3
+     {"Finder",     (PyObject *)&FinderType},
+ #endif
  };
  
  typedef int (*object_adder)(PyObject *, const char *, PyObject *);
***************
*** 5417,5421 ****
--- 5656,5672 ----
      else
  	PyErr_Clear();
  
+     if (!(vim_special_path_object = PyString_FromString(vim_special_path)))
+ 	return -1;
+ 
+     ADD_OBJECT(m, "VIM_SPECIAL_PATH", vim_special_path_object);
+ 
+ #if PY_MAJOR_VERSION >= 3
+     ADD_OBJECT(m, "_PathFinder", path_finder);
+     ADD_CHECKED_OBJECT(m, "_find_module",
+ 	    (py_find_module = PyObject_GetAttrString(path_finder,
+ 						     "find_module")));
+ #endif
+ 
      return 0;
  }
*** ../vim-7.3.1162/src/if_python.c	2013-06-10 20:47:33.000000000 +0200
--- src/if_python.c	2013-06-10 20:55:04.000000000 +0200
***************
*** 24,32 ****
  /* uncomment this if used with the debug version of python.
   * Checked on 2.7.4. */
  /* #define Py_DEBUG */
! /* Note: most of time you can add -DPy_DEBUG to CFLAGS in place of uncommenting 
   */
! /* uncomment this if used with the debug version of python, but without its 
   * allocator */
  /* #define Py_DEBUG_NO_PYMALLOC */
  
--- 24,32 ----
  /* uncomment this if used with the debug version of python.
   * Checked on 2.7.4. */
  /* #define Py_DEBUG */
! /* Note: most of time you can add -DPy_DEBUG to CFLAGS in place of uncommenting
   */
! /* uncomment this if used with the debug version of python, but without its
   * allocator */
  /* #define Py_DEBUG_NO_PYMALLOC */
  
***************
*** 168,173 ****
--- 168,174 ----
  # define PyErr_SetNone dll_PyErr_SetNone
  # define PyErr_SetString dll_PyErr_SetString
  # define PyErr_SetObject dll_PyErr_SetObject
+ # define PyErr_ExceptionMatches dll_PyErr_ExceptionMatches
  # define PyEval_InitThreads dll_PyEval_InitThreads
  # define PyEval_RestoreThread dll_PyEval_RestoreThread
  # define PyEval_SaveThread dll_PyEval_SaveThread
***************
*** 184,189 ****
--- 185,191 ----
  # define PyLong_Type (*dll_PyLong_Type)
  # define PyList_GetItem dll_PyList_GetItem
  # define PyList_Append dll_PyList_Append
+ # define PyList_Insert dll_PyList_Insert
  # define PyList_New dll_PyList_New
  # define PyList_SetItem dll_PyList_SetItem
  # define PyList_Size dll_PyList_Size
***************
*** 233,238 ****
--- 235,241 ----
  # define PyFloat_Type (*dll_PyFloat_Type)
  # define PyImport_AddModule (*dll_PyImport_AddModule)
  # define PySys_SetObject dll_PySys_SetObject
+ # define PySys_GetObject dll_PySys_GetObject
  # define PySys_SetArgv dll_PySys_SetArgv
  # define PyType_Type (*dll_PyType_Type)
  # define PyType_Ready (*dll_PyType_Ready)
***************
*** 305,310 ****
--- 308,314 ----
  static void(*dll_PyErr_SetNone)(PyObject *);
  static void(*dll_PyErr_SetString)(PyObject *, const char *);
  static void(*dll_PyErr_SetObject)(PyObject *, PyObject *);
+ static int(*dll_PyErr_ExceptionMatches)(PyObject *);
  static void(*dll_PyEval_InitThreads)(void);
  static void(*dll_PyEval_RestoreThread)(PyThreadState *);
  static PyThreadState*(*dll_PyEval_SaveThread)(void);
***************
*** 320,326 ****
  static PyTypeObject* dll_PyInt_Type;
  static PyTypeObject* dll_PyLong_Type;
  static PyObject*(*dll_PyList_GetItem)(PyObject *, PyInt);
! static PyObject*(*dll_PyList_Append)(PyObject *, PyObject *);
  static PyObject*(*dll_PyList_New)(PyInt size);
  static int(*dll_PyList_SetItem)(PyObject *, PyInt, PyObject *);
  static PyInt(*dll_PyList_Size)(PyObject *);
--- 324,331 ----
  static PyTypeObject* dll_PyInt_Type;
  static PyTypeObject* dll_PyLong_Type;
  static PyObject*(*dll_PyList_GetItem)(PyObject *, PyInt);
! static int(*dll_PyList_Append)(PyObject *, PyObject *);
! static int(*dll_PyList_Insert)(PyObject *, int, PyObject *);
  static PyObject*(*dll_PyList_New)(PyInt size);
  static int(*dll_PyList_SetItem)(PyObject *, PyInt, PyObject *);
  static PyInt(*dll_PyList_Size)(PyObject *);
***************
*** 366,371 ****
--- 371,377 ----
  static PyObject*(*dll_PyFloat_FromDouble)(double);
  static PyTypeObject* dll_PyFloat_Type;
  static int(*dll_PySys_SetObject)(char *, PyObject *);
+ static PyObject *(*dll_PySys_GetObject)(char *);
  static int(*dll_PySys_SetArgv)(int, char **);
  static PyTypeObject* dll_PyType_Type;
  static int (*dll_PyType_Ready)(PyTypeObject *type);
***************
*** 431,436 ****
--- 437,443 ----
  static PyObject *imp_PyExc_TypeError;
  static PyObject *imp_PyExc_ValueError;
  static PyObject *imp_PyExc_RuntimeError;
+ static PyObject *imp_PyExc_ImportError;
  
  # define PyExc_AttributeError imp_PyExc_AttributeError
  # define PyExc_IndexError imp_PyExc_IndexError
***************
*** 439,444 ****
--- 446,452 ----
  # define PyExc_TypeError imp_PyExc_TypeError
  # define PyExc_ValueError imp_PyExc_ValueError
  # define PyExc_RuntimeError imp_PyExc_RuntimeError
+ # define PyExc_ImportError imp_PyExc_ImportError
  
  /*
   * Table of name to function pointer of python.
***************
*** 471,476 ****
--- 479,485 ----
      {"PyErr_SetNone", (PYTHON_PROC*)&dll_PyErr_SetNone},
      {"PyErr_SetString", (PYTHON_PROC*)&dll_PyErr_SetString},
      {"PyErr_SetObject", (PYTHON_PROC*)&dll_PyErr_SetObject},
+     {"PyErr_ExceptionMatches", (PYTHON_PROC*)&dll_PyErr_ExceptionMatches},
      {"PyEval_InitThreads", (PYTHON_PROC*)&dll_PyEval_InitThreads},
      {"PyEval_RestoreThread", (PYTHON_PROC*)&dll_PyEval_RestoreThread},
      {"PyEval_SaveThread", (PYTHON_PROC*)&dll_PyEval_SaveThread},
***************
*** 487,492 ****
--- 496,502 ----
      {"PyLong_Type", (PYTHON_PROC*)&dll_PyLong_Type},
      {"PyList_GetItem", (PYTHON_PROC*)&dll_PyList_GetItem},
      {"PyList_Append", (PYTHON_PROC*)&dll_PyList_Append},
+     {"PyList_Insert", (PYTHON_PROC*)&dll_PyList_Insert},
      {"PyList_New", (PYTHON_PROC*)&dll_PyList_New},
      {"PyList_SetItem", (PYTHON_PROC*)&dll_PyList_SetItem},
      {"PyList_Size", (PYTHON_PROC*)&dll_PyList_Size},
***************
*** 532,537 ****
--- 542,548 ----
      {"PyFloat_FromDouble", (PYTHON_PROC*)&dll_PyFloat_FromDouble},
      {"PyImport_AddModule", (PYTHON_PROC*)&dll_PyImport_AddModule},
      {"PySys_SetObject", (PYTHON_PROC*)&dll_PySys_SetObject},
+     {"PySys_GetObject", (PYTHON_PROC*)&dll_PySys_GetObject},
      {"PySys_SetArgv", (PYTHON_PROC*)&dll_PySys_SetArgv},
      {"PyType_Type", (PYTHON_PROC*)&dll_PyType_Type},
      {"PyType_Ready", (PYTHON_PROC*)&dll_PyType_Ready},
***************
*** 706,711 ****
--- 717,723 ----
      imp_PyExc_TypeError = PyDict_GetItemString(exdict, "TypeError");
      imp_PyExc_ValueError = PyDict_GetItemString(exdict, "ValueError");
      imp_PyExc_RuntimeError = PyDict_GetItemString(exdict, "RuntimeError");
+     imp_PyExc_ImportError = PyDict_GetItemString(exdict, "ImportError");
      Py_XINCREF(imp_PyExc_AttributeError);
      Py_XINCREF(imp_PyExc_IndexError);
      Py_XINCREF(imp_PyExc_KeyError);
***************
*** 713,718 ****
--- 725,731 ----
      Py_XINCREF(imp_PyExc_TypeError);
      Py_XINCREF(imp_PyExc_ValueError);
      Py_XINCREF(imp_PyExc_RuntimeError);
+     Py_XINCREF(imp_PyExc_ImportError);
      Py_XDECREF(exmod);
  }
  #endif /* DYNAMIC_PYTHON */
***************
*** 735,740 ****
--- 748,757 ----
  static PyObject *ListGetattr(PyObject *, char *);
  static PyObject *FunctionGetattr(PyObject *, char *);
  
+ static PyObject *LoaderLoadModule(PyObject *, PyObject *);
+ static PyObject *FinderFindModule(PyObject *, PyObject *);
+ static PyObject *VimPathHook(PyObject *, PyObject *);
+ 
  #ifndef Py_VISIT
  # define Py_VISIT(obj) visit(obj, arg)
  #endif
***************
*** 1359,1369 ****
  }
  #endif
  
      static int
  PythonMod_Init(void)
  {
-     PyObject *mod;
- 
      /* The special value is removed from sys.path in Python_Init(). */
      static char *(argv[2]) = {"/must>not&exist/foo", NULL};
  
--- 1376,1487 ----
  }
  #endif
  
+     static PyObject *
+ LoaderLoadModule(PyObject *self, PyObject *args)
+ {
+     char	*fullname;
+     PyObject	*path;
+     PyObject	*meta_path;
+     PyObject	*path_hooks;
+     PyObject	*new_path;
+     PyObject	*r;
+     PyObject	*new_list;
+ 
+     if (!PyArg_ParseTuple(args, "s", &fullname))
+ 	return NULL;
+ 
+     if (!(new_path = Vim_GetPaths(self)))
+ 	return NULL;
+ 
+     if (!(new_list = PyList_New(0)))
+ 	return NULL;
+ 
+ #define GET_SYS_OBJECT(objstr, obj) \
+     obj = PySys_GetObject(objstr); \
+     PyErr_Clear(); \
+     Py_XINCREF(obj);
+ 
+     GET_SYS_OBJECT("meta_path", meta_path);
+     if (PySys_SetObject("meta_path", new_list))
+     {
+ 	Py_XDECREF(meta_path);
+ 	Py_DECREF(new_list);
+ 	return NULL;
+     }
+     Py_DECREF(new_list); /* Now it becomes a reference borrowed from
+ 			    sys.meta_path */
+ 
+ #define RESTORE_SYS_OBJECT(objstr, obj) \
+     if (obj) \
+     { \
+ 	PySys_SetObject(objstr, obj); \
+ 	Py_DECREF(obj); \
+     }
+ 
+     GET_SYS_OBJECT("path_hooks", path_hooks);
+     if (PySys_SetObject("path_hooks", new_list))
+     {
+ 	RESTORE_SYS_OBJECT("meta_path", meta_path);
+ 	Py_XDECREF(path_hooks);
+ 	return NULL;
+     }
+ 
+     GET_SYS_OBJECT("path", path);
+     if (PySys_SetObject("path", new_path))
+     {
+ 	RESTORE_SYS_OBJECT("meta_path", meta_path);
+ 	RESTORE_SYS_OBJECT("path_hooks", path_hooks);
+ 	Py_XDECREF(path);
+ 	return NULL;
+     }
+     Py_DECREF(new_path);
+ 
+     r = PyImport_ImportModule(fullname);
+ 
+     RESTORE_SYS_OBJECT("meta_path", meta_path);
+     RESTORE_SYS_OBJECT("path_hooks", path_hooks);
+     RESTORE_SYS_OBJECT("path", path);
+ 
+     if (PyErr_Occurred())
+     {
+ 	Py_XDECREF(r);
+ 	return NULL;
+     }
+ 
+     return r;
+ }
+ 
+     static PyObject *
+ FinderFindModule(PyObject *self UNUSED, PyObject *args UNUSED)
+ {
+     /*
+      * Don't bother actually finding the module, it is delegated to the "loader"
+      * object (which is basically the same object: vim module).
+      */
+     Py_INCREF(vim_module);
+     return vim_module;
+ }
+ 
+     static PyObject *
+ VimPathHook(PyObject *self UNUSED, PyObject *args)
+ {
+     char	*path;
+ 
+     if (PyArg_ParseTuple(args, "s", &path)
+ 	    && STRCMP(path, vim_special_path) == 0)
+     {
+ 	Py_INCREF(vim_module);
+ 	return vim_module;
+     }
+ 
+     PyErr_Clear();
+     PyErr_SetNone(PyExc_ImportError);
+     return NULL;
+ }
+ 
      static int
  PythonMod_Init(void)
  {
      /* The special value is removed from sys.path in Python_Init(). */
      static char *(argv[2]) = {"/must>not&exist/foo", NULL};
  
***************
*** 1373,1382 ****
      /* Set sys.argv[] to avoid a crash in warn(). */
      PySys_SetArgv(1, argv);
  
!     mod = Py_InitModule4("vim", VimMethods, (char *)NULL, (PyObject *)NULL,
! 			    PYTHON_API_VERSION);
  
!     return populate_module(mod, PyModule_AddObject, PyObject_GetAttrString);
  }
  
  /*************************************************************************
--- 1491,1507 ----
      /* Set sys.argv[] to avoid a crash in warn(). */
      PySys_SetArgv(1, argv);
  
!     vim_module = Py_InitModule4("vim", VimMethods, (char *)NULL,
! 				(PyObject *)NULL, PYTHON_API_VERSION);
! 
!     if (populate_module(vim_module, PyModule_AddObject,
! 			   PyObject_GetAttrString))
! 	return -1;
! 
!     if (init_sys_path())
! 	return -1;
  
!     return 0;
  }
  
  /*************************************************************************
*** ../vim-7.3.1162/src/if_python3.c	2013-06-10 18:36:20.000000000 +0200
--- src/if_python3.c	2013-06-10 20:55:44.000000000 +0200
***************
*** 134,139 ****
--- 134,140 ----
  # define PyErr_SetNone py3_PyErr_SetNone
  # define PyErr_SetString py3_PyErr_SetString
  # define PyErr_SetObject py3_PyErr_SetObject
+ # define PyErr_ExceptionMatches py3_PyErr_ExceptionMatches
  # define PyEval_InitThreads py3_PyEval_InitThreads
  # define PyEval_RestoreThread py3_PyEval_RestoreThread
  # define PyEval_SaveThread py3_PyEval_SaveThread
***************
*** 143,148 ****
--- 144,150 ----
  # define PyLong_FromLong py3_PyLong_FromLong
  # define PyList_GetItem py3_PyList_GetItem
  # define PyList_Append py3_PyList_Append
+ # define PyList_Insert py3_PyList_Insert
  # define PyList_New py3_PyList_New
  # define PyList_SetItem py3_PyList_SetItem
  # define PyList_Size py3_PyList_Size
***************
*** 177,182 ****
--- 179,185 ----
  # define PyEval_GetLocals py3_PyEval_GetLocals
  # define PyEval_GetGlobals py3_PyEval_GetGlobals
  # define PySys_SetObject py3_PySys_SetObject
+ # define PySys_GetObject py3_PySys_GetObject
  # define PySys_SetArgv py3_PySys_SetArgv
  # define PyType_Ready py3_PyType_Ready
  #undef Py_BuildValue
***************
*** 268,274 ****
  static PyGILState_STATE (*py3_PyGILState_Ensure)(void);
  static void (*py3_PyGILState_Release)(PyGILState_STATE);
  static int (*py3_PySys_SetObject)(char *, PyObject *);
! static PyObject* (*py3_PyList_Append)(PyObject *, PyObject *);
  static Py_ssize_t (*py3_PyList_Size)(PyObject *);
  static int (*py3_PySequence_Check)(PyObject *);
  static Py_ssize_t (*py3_PySequence_Size)(PyObject *);
--- 271,279 ----
  static PyGILState_STATE (*py3_PyGILState_Ensure)(void);
  static void (*py3_PyGILState_Release)(PyGILState_STATE);
  static int (*py3_PySys_SetObject)(char *, PyObject *);
! static PyObject* (*py3_PySys_GetObject)(char *);
! static int (*py3_PyList_Append)(PyObject *, PyObject *);
! static int (*py3_PyList_Insert)(PyObject *, int, PyObject *);
  static Py_ssize_t (*py3_PyList_Size)(PyObject *);
  static int (*py3_PySequence_Check)(PyObject *);
  static Py_ssize_t (*py3_PySequence_Size)(PyObject *);
***************
*** 284,289 ****
--- 289,295 ----
  static void (*py3_Py_Finalize)(void);
  static void (*py3_PyErr_SetString)(PyObject *, const char *);
  static void (*py3_PyErr_SetObject)(PyObject *, PyObject *);
+ static int (*py3_PyErr_ExceptionMatches)(PyObject *);
  static int (*py3_PyRun_SimpleString)(char *);
  static PyObject* (*py3_PyRun_String)(char *, int, PyObject *, PyObject *);
  static PyObject* (*py3_PyObject_GetAttrString)(PyObject *, const char *);
***************
*** 393,398 ****
--- 399,405 ----
  static PyObject *p3imp_PyExc_TypeError;
  static PyObject *p3imp_PyExc_ValueError;
  static PyObject *p3imp_PyExc_RuntimeError;
+ static PyObject *p3imp_PyExc_ImportError;
  
  # define PyExc_AttributeError p3imp_PyExc_AttributeError
  # define PyExc_IndexError p3imp_PyExc_IndexError
***************
*** 401,406 ****
--- 408,414 ----
  # define PyExc_TypeError p3imp_PyExc_TypeError
  # define PyExc_ValueError p3imp_PyExc_ValueError
  # define PyExc_RuntimeError p3imp_PyExc_RuntimeError
+ # define PyExc_ImportError p3imp_PyExc_ImportError
  
  /*
   * Table of name to function pointer of python.
***************
*** 428,434 ****
--- 436,444 ----
      {"PyGILState_Ensure", (PYTHON_PROC*)&py3_PyGILState_Ensure},
      {"PyGILState_Release", (PYTHON_PROC*)&py3_PyGILState_Release},
      {"PySys_SetObject", (PYTHON_PROC*)&py3_PySys_SetObject},
+     {"PySys_GetObject", (PYTHON_PROC*)&py3_PySys_GetObject},
      {"PyList_Append", (PYTHON_PROC*)&py3_PyList_Append},
+     {"PyList_Insert", (PYTHON_PROC*)&py3_PyList_Insert},
      {"PyList_Size", (PYTHON_PROC*)&py3_PyList_Size},
      {"PySequence_Check", (PYTHON_PROC*)&py3_PySequence_Check},
      {"PySequence_Size", (PYTHON_PROC*)&py3_PySequence_Size},
***************
*** 441,446 ****
--- 451,457 ----
      {"Py_Finalize", (PYTHON_PROC*)&py3_Py_Finalize},
      {"PyErr_SetString", (PYTHON_PROC*)&py3_PyErr_SetString},
      {"PyErr_SetObject", (PYTHON_PROC*)&py3_PyErr_SetObject},
+     {"PyErr_ExceptionMatches", (PYTHON_PROC*)&py3_PyErr_ExceptionMatches},
      {"PyRun_SimpleString", (PYTHON_PROC*)&py3_PyRun_SimpleString},
      {"PyRun_String", (PYTHON_PROC*)&py3_PyRun_String},
      {"PyObject_GetAttrString", (PYTHON_PROC*)&py3_PyObject_GetAttrString},
***************
*** 664,669 ****
--- 675,681 ----
      p3imp_PyExc_TypeError = PyDict_GetItemString(exdict, "TypeError");
      p3imp_PyExc_ValueError = PyDict_GetItemString(exdict, "ValueError");
      p3imp_PyExc_RuntimeError = PyDict_GetItemString(exdict, "RuntimeError");
+     p3imp_PyExc_ImportError = PyDict_GetItemString(exdict, "ImportError");
      Py_XINCREF(p3imp_PyExc_AttributeError);
      Py_XINCREF(p3imp_PyExc_IndexError);
      Py_XINCREF(p3imp_PyExc_KeyError);
***************
*** 671,676 ****
--- 683,689 ----
      Py_XINCREF(p3imp_PyExc_TypeError);
      Py_XINCREF(p3imp_PyExc_ValueError);
      Py_XINCREF(p3imp_PyExc_RuntimeError);
+     Py_XINCREF(p3imp_PyExc_ImportError);
      Py_XDECREF(exmod);
  }
  #endif /* DYNAMIC_PYTHON3 */
***************
*** 723,730 ****
--- 736,748 ----
  static int ListSetattro(PyObject *, PyObject *, PyObject *);
  static PyObject *FunctionGetattro(PyObject *, PyObject *);
  
+ static PyObject *VimPathHook(PyObject *, PyObject *);
+ 
  static struct PyModuleDef vimmodule;
  
+ static PyObject *path_finder;
+ static PyObject *py_find_module = NULL;
+ 
  #define PY_CAN_RECURSE
  
  /*
***************
*** 1585,1596 ****
  #endif
  
      static PyObject *
! Py3Init_vim(void)
  {
!     PyObject *mod;
  
      /* The special value is removed from sys.path in Python3_Init(). */
      static wchar_t *(argv[2]) = {L"/must>not&exist/foo", NULL};
  
      if (init_types())
  	return NULL;
--- 1603,1672 ----
  #endif
  
      static PyObject *
! VimPathHook(PyObject *self UNUSED, PyObject *args)
  {
!     char	*path;
! 
!     if (PyArg_ParseTuple(args, "s", &path)
! 	    && STRCMP(path, vim_special_path) == 0)
!     {
! 	Py_INCREF(&FinderType);
! 	return (PyObject *) &FinderType;
!     }
! 
!     PyErr_Clear();
!     PyErr_SetNone(PyExc_ImportError);
!     return NULL;
! }
! 
!     static PyObject *
! FinderFindModule(PyObject *cls UNUSED, PyObject *fullname)
! {
!     PyObject	*new_path;
!     PyObject	*r;
! 
!     if (!(new_path = Vim_GetPaths(NULL)))
! 	return NULL;
! 
!     /* call find_module of the super() class */
!     r = PyObject_CallFunctionObjArgs(py_find_module, fullname, new_path, NULL);
! 
!     Py_DECREF(new_path);
! 
!     return r;
! }
  
+ static struct PyMethodDef FinderMethods[] = {
+     {"find_module",	FinderFindModule,	METH_CLASS|METH_O,	""},
+     {NULL,		NULL,			0,			NULL}
+ };
+ 
+     static PyObject *
+ Py3Init_vim(void)
+ {
      /* The special value is removed from sys.path in Python3_Init(). */
      static wchar_t *(argv[2]) = {L"/must>not&exist/foo", NULL};
+     PyObject	*importlib_machinery;
+ 
+     if (!(importlib_machinery = PyImport_ImportModule("importlib.machinery")))
+ 	return NULL;
+ 
+     if (!(path_finder = PyObject_GetAttrString(importlib_machinery,
+ 					       "PathFinder")))
+     {
+ 	Py_DECREF(importlib_machinery);
+ 	return NULL;
+     }
+ 
+     Py_DECREF(importlib_machinery);
+ 
+     vim_memset(&FinderType, 0, sizeof(FinderObject));
+     FinderType.tp_name = "vim.Finder";
+     FinderType.tp_basicsize = sizeof(FinderObject);
+     FinderType.tp_base = (PyTypeObject *) path_finder;
+     FinderType.tp_flags = Py_TPFLAGS_DEFAULT;
+     FinderType.tp_doc = "Vim finder class, for use with path hook";
+     FinderType.tp_methods = FinderMethods;
  
      if (init_types())
  	return NULL;
***************
*** 1598,1611 ****
      /* Set sys.argv[] to avoid a crash in warn(). */
      PySys_SetArgv(1, argv);
  
!     mod = PyModule_Create(&vimmodule);
!     if (mod == NULL)
  	return NULL;
  
!     if (populate_module(mod, PyModule_AddObject, PyObject_GetAttrString))
  	return NULL;
  
!     return mod;
  }
  
  /*************************************************************************
--- 1674,1689 ----
      /* Set sys.argv[] to avoid a crash in warn(). */
      PySys_SetArgv(1, argv);
  
!     if ((vim_module = PyModule_Create(&vimmodule)) == NULL)
! 	return NULL;
! 
!     if (populate_module(vim_module, PyModule_AddObject, PyObject_GetAttrString))
  	return NULL;
  
!     if (init_sys_path())
  	return NULL;
  
!     return vim_module;
  }
  
  /*************************************************************************
*** ../vim-7.3.1162/src/testdir/test86.in	2013-06-02 18:54:16.000000000 +0200
--- src/testdir/test86.in	2013-06-10 21:05:44.000000000 +0200
***************
*** 1069,1074 ****
--- 1069,1082 ----
  ee('vim.current.xxx = True')
  EOF
  :"
+ :" Test import  TODO: BROKEN
+ :"py << EOF
+ :"vim.options['rtp'] = os.getcwd().replace(',', '\\,').replace('\\', '\\\\')
+ :"from module import dir as d
+ :"from modulex import ddir
+ :"cb.append(d + ',' + ddir)
+ :"EOF
+ :"
  :" Test exceptions
  :fun Exe(e)
  :   execute a:e
*** ../vim-7.3.1162/src/testdir/test87.in	2013-06-02 18:54:16.000000000 +0200
--- src/testdir/test87.in	2013-06-10 21:06:37.000000000 +0200
***************
*** 1036,1041 ****
--- 1036,1049 ----
  ee('vim.current.xxx = True')
  EOF
  :"
+ :" Test import  TODO: BROKEN
+ :"py3 << EOF
+ :"vim.options['rtp'] = os.getcwd().replace(',', '\\,').replace('\\', '\\\\')
+ :"from module import dir as d
+ :"from modulex import ddir
+ :"cb.append(d + ',' + ddir)
+ :"EOF
+ :"
  :" Test exceptions
  :fun Exe(e)
  :   execute a:e
*** ../vim-7.3.1162/src/auto/configure	2013-06-02 19:14:11.000000000 +0200
--- src/auto/configure	2013-06-10 21:22:52.000000000 +0200
***************
*** 5289,5298 ****
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $vi_cv_var_python_version" >&5
  $as_echo "$vi_cv_var_python_version" >&6; }
  
!         { $as_echo "$as_me:${as_lineno-$LINENO}: checking Python is 2.2 or better" >&5
! $as_echo_n "checking Python is 2.2 or better... " >&6; }
      if ${vi_cv_path_python} -c \
! 	"import sys; sys.exit(${vi_cv_var_python_version} < 2.2)"
      then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yep" >&5
  $as_echo "yep" >&6; }
--- 5289,5298 ----
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $vi_cv_var_python_version" >&5
  $as_echo "$vi_cv_var_python_version" >&6; }
  
!         { $as_echo "$as_me:${as_lineno-$LINENO}: checking Python is 2.3 or better" >&5
! $as_echo_n "checking Python is 2.3 or better... " >&6; }
      if ${vi_cv_path_python} -c \
! 	"import sys; sys.exit(${vi_cv_var_python_version} < 2.3)"
      then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yep" >&5
  $as_echo "yep" >&6; }
*** ../vim-7.3.1162/src/version.c	2013-06-10 20:47:33.000000000 +0200
--- src/version.c	2013-06-10 20:53:23.000000000 +0200
***************
*** 730,731 ****
--- 730,733 ----
  {   /* Add new patch number below this line */
+ /**/
+     1163,
  /**/
 
-- 
The coffee just wasn't strong enough to defend itself -- Tom Waits
 
 /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
\\\  an exciting new programming language -- http://www.Zimbu.org        ///
 \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///