diff --git a/7.3.1174 b/7.3.1174
new file mode 100644
index 0000000..c7a0156
--- /dev/null
+++ b/7.3.1174
@@ -0,0 +1,835 @@
+To: vim_dev@googlegroups.com
+Subject: Patch 7.3.1174
+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.1174
+Problem: Python 2 and 3 use different ways to load modules.
+Solution: Use the same method. (ZyX)
+Files: runtime/doc/if_pyth.txt, src/if_py_both.h, src/if_python3.c,
+ src/if_python.c
+
+
+*** ../vim-7.3.1173/runtime/doc/if_pyth.txt 2013-06-12 14:20:15.000000000 +0200
+--- runtime/doc/if_pyth.txt 2013-06-12 14:33:12.000000000 +0200
+***************
+*** 315,321 ****
+ {rtp}/python2 (or python3) and {rtp}/pythonx (for both python versions) for
+ each {rtp} found in 'runtimepath'.
+
+! Implementation for python 2 is similar to the following, but written in C: >
+
+ from imp import find_module, load_module
+ import vim
+--- 315,321 ----
+ {rtp}/python2 (or python3) and {rtp}/pythonx (for both python versions) for
+ each {rtp} found in 'runtimepath'.
+
+! Implementation is similar to the following, but written in C: >
+
+ from imp import find_module, load_module
+ import vim
+***************
+*** 344,359 ****
+ # matter for python which object has find_module function attached to as
+ # an attribute.
+ class VimPathFinder(object):
+ def find_module(cls, fullname, path=None):
+ try:
+ return VimModuleLoader(_find_module(fullname, fullname, path or vim._get_paths()))
+ except ImportError:
+ return None
+- find_module = classmethod(find_module)
+
+ def load_module(cls, fullname, path=None):
+ return _find_module(fullname, fullname, path or vim._get_paths())
+- load_module = classmethod(load_module)
+
+ def hook(path):
+ if path == vim.VIM_SPECIAL_PATH:
+--- 344,359 ----
+ # matter for python which object has find_module function attached to as
+ # an attribute.
+ class VimPathFinder(object):
++ @classmethod
+ def find_module(cls, fullname, path=None):
+ try:
+ return VimModuleLoader(_find_module(fullname, fullname, path or vim._get_paths()))
+ except ImportError:
+ return None
+
++ @classmethod
+ def load_module(cls, fullname, path=None):
+ return _find_module(fullname, fullname, path or vim._get_paths())
+
+ def hook(path):
+ if path == vim.VIM_SPECIAL_PATH:
+***************
+*** 363,392 ****
+
+ sys.path_hooks.append(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
+--- 363,368 ----
+***************
+*** 402,409 ****
+ 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, 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
+--- 378,384 ----
+ 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.
+
+ vim._get_paths *python-_get_paths*
+ Methods returning a list of paths which will be searched for by path
+*** ../vim-7.3.1173/src/if_py_both.h 2013-06-12 14:20:15.000000000 +0200
+--- src/if_py_both.h 2013-06-12 14:35:42.000000000 +0200
+***************
+*** 60,65 ****
+--- 60,70 ----
+ static PyObject *vim_module;
+ static PyObject *vim_special_path_object;
+
++ static PyObject *py_find_module;
++ static PyObject *py_load_module;
++
++ static PyObject *VimError;
++
+ /*
+ * obtain a lock on the Vim data structures
+ */
+***************
+*** 393,400 ****
+ return 0;
+ }
+
+
+! static PyObject *VimError;
+
+ /* Check to see whether a Vim error has been reported, or a keyboard
+ * interrupt has been detected.
+--- 398,431 ----
+ return 0;
+ }
+
++ typedef struct
++ {
++ PyObject_HEAD
++ PyObject *module;
++ } LoaderObject;
++ static PyTypeObject LoaderType;
++
++ static void
++ LoaderDestructor(LoaderObject *self)
++ {
++ Py_DECREF(self->module);
++ DESTRUCTOR_FINISH(self);
++ }
++
++ static PyObject *
++ LoaderLoadModule(LoaderObject *self, PyObject *args UNUSED)
++ {
++ PyObject *r = self->module;
+
+! Py_INCREF(r);
+! return r;
+! }
+!
+! static struct PyMethodDef LoaderMethods[] = {
+! /* name, function, calling, doc */
+! {"load_module", (PyCFunction)LoaderLoadModule, METH_VARARGS, ""},
+! { NULL, NULL, 0, NULL}
+! };
+
+ /* Check to see whether a Vim error has been reported, or a keyboard
+ * interrupt has been detected.
+***************
+*** 925,930 ****
+--- 956,1105 ----
+ return r;
+ }
+
++ static PyObject *
++ call_load_module(char *name, int len, PyObject *find_module_result)
++ {
++ PyObject *fd, *pathname, *description;
++
++ if (!PyTuple_Check(find_module_result)
++ || PyTuple_GET_SIZE(find_module_result) != 3)
++ {
++ PyErr_SetString(PyExc_TypeError,
++ _("expected 3-tuple as imp.find_module() result"));
++ return NULL;
++ }
++
++ if (!(fd = PyTuple_GET_ITEM(find_module_result, 0))
++ || !(pathname = PyTuple_GET_ITEM(find_module_result, 1))
++ || !(description = PyTuple_GET_ITEM(find_module_result, 2)))
++ {
++ PyErr_SetString(PyExc_RuntimeError,
++ _("internal error: imp.find_module returned tuple with NULL"));
++ return NULL;
++ }
++
++ return PyObject_CallFunction(py_load_module,
++ "s#OOO", name, len, fd, pathname, description);
++ }
++
++ static PyObject *
++ find_module(char *fullname, char *tail, PyObject *new_path)
++ {
++ PyObject *find_module_result;
++ PyObject *module;
++ char *dot;
++
++ if ((dot = (char *) vim_strchr((char_u *) tail, '.')))
++ {
++ /*
++ * There is a dot in the name: call find_module recursively without the
++ * first component
++ */
++ PyObject *newest_path;
++ int partlen = (int) (dot - 1 - tail);
++
++ if (!(find_module_result = PyObject_CallFunction(py_find_module,
++ "s#O", tail, partlen, new_path)))
++ return NULL;
++
++ if (!(module = call_load_module(
++ fullname,
++ ((int) (tail - fullname)) + partlen,
++ find_module_result)))
++ {
++ Py_DECREF(find_module_result);
++ return NULL;
++ }
++
++ Py_DECREF(find_module_result);
++
++ if (!(newest_path = PyObject_GetAttrString(module, "__path__")))
++ {
++ Py_DECREF(module);
++ return NULL;
++ }
++
++ Py_DECREF(module);
++
++ module = find_module(fullname, dot + 1, newest_path);
++
++ Py_DECREF(newest_path);
++
++ return module;
++ }
++ else
++ {
++ if (!(find_module_result = PyObject_CallFunction(py_find_module,
++ "sO", tail, new_path)))
++ return NULL;
++
++ if (!(module = call_load_module(
++ fullname,
++ STRLEN(fullname),
++ find_module_result)))
++ {
++ Py_DECREF(find_module_result);
++ return NULL;
++ }
++
++ Py_DECREF(find_module_result);
++
++ return module;
++ }
++ }
++
++ static PyObject *
++ FinderFindModule(PyObject *self, PyObject *args)
++ {
++ char *fullname;
++ PyObject *module;
++ PyObject *new_path;
++ LoaderObject *loader;
++
++ if (!PyArg_ParseTuple(args, "s", &fullname))
++ return NULL;
++
++ if (!(new_path = Vim_GetPaths(self)))
++ return NULL;
++
++ module = find_module(fullname, fullname, new_path);
++
++ Py_DECREF(new_path);
++
++ if (!module)
++ {
++ Py_INCREF(Py_None);
++ return Py_None;
++ }
++
++ if (!(loader = PyObject_NEW(LoaderObject, &LoaderType)))
++ {
++ Py_DECREF(module);
++ return NULL;
++ }
++
++ loader->module = module;
++
++ return (PyObject *) loader;
++ }
++
++ 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;
++ }
++
+ /*
+ * Vim module - Definitions
+ */
+***************
+*** 938,946 ****
+ {"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"},
+- #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}
+--- 1113,1119 ----
+***************
+*** 5188,5208 ****
+ } CurrentObject;
+ static PyTypeObject CurrentType;
+
+- #if PY_MAJOR_VERSION >= 3
+- typedef struct
+- {
+- PyObject_HEAD
+- } FinderObject;
+- static PyTypeObject FinderType;
+- #else
+- typedef struct
+- {
+- PyObject_HEAD
+- PyObject *module;
+- } LoaderObject;
+- static PyTypeObject LoaderType;
+- #endif
+-
+ static void
+ init_structs(void)
+ {
+--- 5361,5366 ----
+***************
+*** 5418,5423 ****
+--- 5576,5589 ----
+ OptionsType.tp_traverse = (traverseproc)OptionsTraverse;
+ OptionsType.tp_clear = (inquiry)OptionsClear;
+
++ vim_memset(&LoaderType, 0, sizeof(LoaderType));
++ LoaderType.tp_name = "vim.Loader";
++ LoaderType.tp_basicsize = sizeof(LoaderObject);
++ LoaderType.tp_flags = Py_TPFLAGS_DEFAULT;
++ LoaderType.tp_doc = "vim message object";
++ LoaderType.tp_methods = LoaderMethods;
++ LoaderType.tp_dealloc = (destructor)LoaderDestructor;
++
+ #if PY_MAJOR_VERSION >= 3
+ vim_memset(&vimmodule, 0, sizeof(vimmodule));
+ vimmodule.m_name = "vim";
+***************
+*** 5448,5458 ****
+ PYTYPE_READY(FunctionType);
+ PYTYPE_READY(OptionsType);
+ PYTYPE_READY(OutputType);
+- #if PY_MAJOR_VERSION >= 3
+- PYTYPE_READY(FinderType);
+- #else
+ PYTYPE_READY(LoaderType);
+- #endif
+ return 0;
+ }
+
+--- 5614,5620 ----
+***************
+*** 5576,5586 ****
+ {"List", (PyObject *)&ListType},
+ {"Function", (PyObject *)&FunctionType},
+ {"Options", (PyObject *)&OptionsType},
+! #if PY_MAJOR_VERSION >= 3
+! {"Finder", (PyObject *)&FinderType},
+! #else
+! {"Loader", (PyObject *)&LoaderType},
+! #endif
+ };
+
+ typedef int (*object_adder)(PyObject *, const char *, PyObject *);
+--- 5738,5744 ----
+ {"List", (PyObject *)&ListType},
+ {"Function", (PyObject *)&FunctionType},
+ {"Options", (PyObject *)&OptionsType},
+! {"_Loader", (PyObject *)&LoaderType},
+ };
+
+ typedef int (*object_adder)(PyObject *, const char *, PyObject *);
+***************
+*** 5604,5609 ****
+--- 5762,5768 ----
+ int i;
+ PyObject *other_module;
+ PyObject *attr;
++ PyObject *imp;
+
+ for (i = 0; i < (int)(sizeof(numeric_constants)
+ / sizeof(struct numeric_constant));
+***************
+*** 5671,5685 ****
+
+ 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")));
+! #else
+ ADD_OBJECT(m, "_find_module", py_find_module);
+ ADD_OBJECT(m, "_load_module", py_load_module);
+- #endif
+
+ return 0;
+ }
+--- 5830,5855 ----
+
+ ADD_OBJECT(m, "VIM_SPECIAL_PATH", vim_special_path_object);
+
+! if (!(imp = PyImport_ImportModule("imp")))
+! return -1;
+!
+! if (!(py_find_module = PyObject_GetAttrString(imp, "find_module")))
+! {
+! Py_DECREF(imp);
+! return -1;
+! }
+!
+! if (!(py_load_module = PyObject_GetAttrString(imp, "load_module")))
+! {
+! Py_DECREF(py_find_module);
+! Py_DECREF(imp);
+! return -1;
+! }
+!
+! Py_DECREF(imp);
+!
+ ADD_OBJECT(m, "_find_module", py_find_module);
+ ADD_OBJECT(m, "_load_module", py_load_module);
+
+ return 0;
+ }
+*** ../vim-7.3.1173/src/if_python3.c 2013-06-10 21:27:18.000000000 +0200
+--- src/if_python3.c 2013-06-12 14:36:00.000000000 +0200
+***************
+*** 175,180 ****
+--- 175,181 ----
+ # define PyObject_HasAttrString py3_PyObject_HasAttrString
+ # define PyObject_SetAttrString py3_PyObject_SetAttrString
+ # define PyObject_CallFunctionObjArgs py3_PyObject_CallFunctionObjArgs
++ # define _PyObject_CallFunction_SizeT py3__PyObject_CallFunction_SizeT
+ # define PyObject_Call py3_PyObject_Call
+ # define PyEval_GetLocals py3_PyEval_GetLocals
+ # define PyEval_GetGlobals py3_PyEval_GetGlobals
+***************
+*** 296,301 ****
+--- 297,303 ----
+ static int (*py3_PyObject_HasAttrString)(PyObject *, const char *);
+ static PyObject* (*py3_PyObject_SetAttrString)(PyObject *, const char *, PyObject *);
+ static PyObject* (*py3_PyObject_CallFunctionObjArgs)(PyObject *, ...);
++ static PyObject* (*py3__PyObject_CallFunction_SizeT)(PyObject *, char *, ...);
+ static PyObject* (*py3_PyObject_Call)(PyObject *, PyObject *, PyObject *);
+ static PyObject* (*py3_PyEval_GetGlobals)();
+ static PyObject* (*py3_PyEval_GetLocals)();
+***************
+*** 458,463 ****
+--- 460,466 ----
+ {"PyObject_HasAttrString", (PYTHON_PROC*)&py3_PyObject_HasAttrString},
+ {"PyObject_SetAttrString", (PYTHON_PROC*)&py3_PyObject_SetAttrString},
+ {"PyObject_CallFunctionObjArgs", (PYTHON_PROC*)&py3_PyObject_CallFunctionObjArgs},
++ {"_PyObject_CallFunction_SizeT", (PYTHON_PROC*)&py3__PyObject_CallFunction_SizeT},
+ {"PyObject_Call", (PYTHON_PROC*)&py3_PyObject_Call},
+ {"PyEval_GetGlobals", (PYTHON_PROC*)&py3_PyEval_GetGlobals},
+ {"PyEval_GetLocals", (PYTHON_PROC*)&py3_PyEval_GetLocals},
+***************
+*** 740,748 ****
+
+ static struct PyModuleDef vimmodule;
+
+- static PyObject *path_finder;
+- static PyObject *py_find_module = NULL;
+-
+ #define PY_CAN_RECURSE
+
+ /*
+--- 743,748 ----
+***************
+*** 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;
+--- 1603,1612 ----
+*** ../vim-7.3.1173/src/if_python.c 2013-06-12 14:20:15.000000000 +0200
+--- src/if_python.c 2013-06-12 14:35:49.000000000 +0200
+***************
+*** 752,763 ****
+ static PyObject *ListGetattr(PyObject *, char *);
+ static PyObject *FunctionGetattr(PyObject *, char *);
+
+- static PyObject *FinderFindModule(PyObject *, PyObject *);
+- static PyObject *VimPathHook(PyObject *, PyObject *);
+-
+- static PyObject *py_find_module;
+- static PyObject *py_load_module;
+-
+ #ifndef Py_VISIT
+ # define Py_VISIT(obj) visit(obj, arg)
+ #endif
+--- 752,757 ----
+***************
+*** 1382,1585 ****
+ }
+ #endif
+
+- static void
+- LoaderDestructor(LoaderObject *self)
+- {
+- Py_DECREF(self->module);
+- DESTRUCTOR_FINISH(self);
+- }
+-
+- static PyObject *
+- LoaderLoadModule(LoaderObject *self, PyObject *args UNUSED)
+- {
+- PyObject *r = self->module;
+-
+- Py_INCREF(r);
+- return r;
+- }
+-
+- static struct PyMethodDef LoaderMethods[] = {
+- /* name, function, calling, doc */
+- {"load_module", (PyCFunction)LoaderLoadModule, METH_VARARGS, ""},
+- { NULL, NULL, 0, NULL}
+- };
+-
+- static PyObject *
+- call_load_module(char *name, int len, PyObject *find_module_result)
+- {
+- PyObject *fd, *pathname, *description;
+-
+- if (!PyTuple_Check(find_module_result)
+- || PyTuple_GET_SIZE(find_module_result) != 3)
+- {
+- PyErr_SetString(PyExc_TypeError,
+- _("expected 3-tuple as imp.find_module() result"));
+- return NULL;
+- }
+-
+- if (!(fd = PyTuple_GET_ITEM(find_module_result, 0))
+- || !(pathname = PyTuple_GET_ITEM(find_module_result, 1))
+- || !(description = PyTuple_GET_ITEM(find_module_result, 2)))
+- {
+- PyErr_SetString(PyExc_RuntimeError,
+- _("internal error: imp.find_module returned tuple with NULL"));
+- return NULL;
+- }
+-
+- return PyObject_CallFunction(py_load_module,
+- "s#OOO", name, len, fd, pathname, description);
+- }
+-
+- static PyObject *
+- find_module(char *fullname, char *tail, PyObject *new_path)
+- {
+- PyObject *find_module_result;
+- PyObject *module;
+- char *dot;
+-
+- if ((dot = (char *) vim_strchr((char_u *) tail, '.')))
+- {
+- /*
+- * There is a dot in the name: call find_module recursively without the
+- * first component
+- */
+- PyObject *newest_path;
+- int partlen = (int) (dot - 1 - tail);
+-
+- if (!(find_module_result = PyObject_CallFunction(py_find_module,
+- "s#O", tail, partlen, new_path)))
+- return NULL;
+-
+- if (!(module = call_load_module(
+- fullname,
+- ((int) (tail - fullname)) + partlen,
+- find_module_result)))
+- {
+- Py_DECREF(find_module_result);
+- return NULL;
+- }
+-
+- Py_DECREF(find_module_result);
+-
+- if (!(newest_path = PyObject_GetAttrString(module, "__path__")))
+- {
+- Py_DECREF(module);
+- return NULL;
+- }
+-
+- Py_DECREF(module);
+-
+- module = find_module(fullname, dot + 1, newest_path);
+-
+- Py_DECREF(newest_path);
+-
+- return module;
+- }
+- else
+- {
+- if (!(find_module_result = PyObject_CallFunction(py_find_module,
+- "sO", tail, new_path)))
+- return NULL;
+-
+- if (!(module = call_load_module(
+- fullname,
+- STRLEN(fullname),
+- find_module_result)))
+- {
+- Py_DECREF(find_module_result);
+- return NULL;
+- }
+-
+- Py_DECREF(find_module_result);
+-
+- return module;
+- }
+- }
+-
+- static PyObject *
+- FinderFindModule(PyObject *self, PyObject *args)
+- {
+- char *fullname;
+- PyObject *module;
+- PyObject *new_path;
+- LoaderObject *loader;
+-
+- if (!PyArg_ParseTuple(args, "s", &fullname))
+- return NULL;
+-
+- if (!(new_path = Vim_GetPaths(self)))
+- return NULL;
+-
+- module = find_module(fullname, fullname, new_path);
+-
+- Py_DECREF(new_path);
+-
+- if (!module)
+- {
+- Py_INCREF(Py_None);
+- return Py_None;
+- }
+-
+- if (!(loader = PyObject_NEW(LoaderObject, &LoaderType)))
+- {
+- Py_DECREF(module);
+- return NULL;
+- }
+-
+- loader->module = module;
+-
+- return (PyObject *) loader;
+- }
+-
+- 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};
+- PyObject *imp;
+-
+- if (!(imp = PyImport_ImportModule("imp")))
+- return -1;
+-
+- if (!(py_find_module = PyObject_GetAttrString(imp, "find_module")))
+- {
+- Py_DECREF(imp);
+- return -1;
+- }
+-
+- if (!(py_load_module = PyObject_GetAttrString(imp, "load_module")))
+- {
+- Py_DECREF(py_find_module);
+- Py_DECREF(imp);
+- return -1;
+- }
+-
+- Py_DECREF(imp);
+-
+- vim_memset(&LoaderType, 0, sizeof(LoaderType));
+- LoaderType.tp_name = "vim.Loader";
+- LoaderType.tp_basicsize = sizeof(LoaderObject);
+- LoaderType.tp_flags = Py_TPFLAGS_DEFAULT;
+- LoaderType.tp_doc = "vim message object";
+- LoaderType.tp_methods = LoaderMethods;
+- LoaderType.tp_dealloc = (destructor)LoaderDestructor;
+
+ if (init_types())
+ return -1;
+--- 1376,1386 ----
+*** ../vim-7.3.1173/src/version.c 2013-06-12 14:26:20.000000000 +0200
+--- src/version.c 2013-06-12 14:35:25.000000000 +0200
+***************
+*** 730,731 ****
+--- 730,733 ----
+ { /* Add new patch number below this line */
++ /**/
++ 1174,
+ /**/
+
+--
+"Hit any key to continue" is very confusing when you have two keyboards.
+
+ /// 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 ///