home *** CD-ROM | disk | FTP | other *** search
/ vim.ftp.fu-berlin.de / 2015-02-03.vim.ftp.fu-berlin.de.tar / vim.ftp.fu-berlin.de / patches / 7.3 / 7.3.1174 < prev    next >
Encoding:
Internet Message Format  |  2013-06-11  |  22.4 KB
  1. To: vim_dev@googlegroups.com
  2. Subject: Patch 7.3.1174
  3. Fcc: outbox
  4. From: Bram Moolenaar <Bram@moolenaar.net>
  5. Mime-Version: 1.0
  6. Content-Type: text/plain; charset=UTF-8
  7. Content-Transfer-Encoding: 8bit
  8. ------------
  9.  
  10. Patch 7.3.1174
  11. Problem:    Python 2 and 3 use different ways to load modules.
  12. Solution:   Use the same method. (ZyX)
  13. Files:        runtime/doc/if_pyth.txt, src/if_py_both.h, src/if_python3.c,
  14.         src/if_python.c
  15.  
  16.  
  17. *** ../vim-7.3.1173/runtime/doc/if_pyth.txt    2013-06-12 14:20:15.000000000 +0200
  18. --- runtime/doc/if_pyth.txt    2013-06-12 14:33:12.000000000 +0200
  19. ***************
  20. *** 315,321 ****
  21.   {rtp}/python2 (or python3) and {rtp}/pythonx (for both python versions) for 
  22.   each {rtp} found in 'runtimepath'.
  23.   
  24. ! Implementation for python 2 is similar to the following, but written in C: >
  25.   
  26.       from imp import find_module, load_module
  27.       import vim
  28. --- 315,321 ----
  29.   {rtp}/python2 (or python3) and {rtp}/pythonx (for both python versions) for 
  30.   each {rtp} found in 'runtimepath'.
  31.   
  32. ! Implementation is similar to the following, but written in C: >
  33.   
  34.       from imp import find_module, load_module
  35.       import vim
  36. ***************
  37. *** 344,359 ****
  38.       # matter for python which object has find_module function attached to as 
  39.       # an attribute.
  40.       class VimPathFinder(object):
  41.           def find_module(cls, fullname, path=None):
  42.               try:
  43.                   return VimModuleLoader(_find_module(fullname, fullname, path or vim._get_paths()))
  44.               except ImportError:
  45.                   return None
  46. -         find_module = classmethod(find_module)
  47.   
  48.           def load_module(cls, fullname, path=None):
  49.               return _find_module(fullname, fullname, path or vim._get_paths())
  50. -         load_module = classmethod(load_module)
  51.   
  52.       def hook(path):
  53.           if path == vim.VIM_SPECIAL_PATH:
  54. --- 344,359 ----
  55.       # matter for python which object has find_module function attached to as 
  56.       # an attribute.
  57.       class VimPathFinder(object):
  58. +         @classmethod
  59.           def find_module(cls, fullname, path=None):
  60.               try:
  61.                   return VimModuleLoader(_find_module(fullname, fullname, path or vim._get_paths()))
  62.               except ImportError:
  63.                   return None
  64.   
  65. +         @classmethod
  66.           def load_module(cls, fullname, path=None):
  67.               return _find_module(fullname, fullname, path or vim._get_paths())
  68.   
  69.       def hook(path):
  70.           if path == vim.VIM_SPECIAL_PATH:
  71. ***************
  72. *** 363,392 ****
  73.   
  74.       sys.path_hooks.append(hook)
  75.   
  76. - Implementation for python 3 is cleaner: code is similar to the following, but, 
  77. - again, written in C: >
  78. - 
  79. -     from importlib.machinery import PathFinder
  80. -     import sys
  81. - 
  82. -     class Finder(PathFinder):
  83. -         @classmethod
  84. -         def find_module(cls, fullname):
  85. -             # see vim._get_paths below
  86. -             new_path = _get_paths()
  87. - 
  88. -             # super().find_module is also a class method
  89. -             # super() is not used because this variant is easier to implement 
  90. -             # in C
  91. -             return PathFinder.find_module(fullname, new_path)
  92. - 
  93. -     def path_hook(path):
  94. -         if path == VIM_SPECIAL_PATH:
  95. -             return Finder
  96. -         raise ImportError
  97. - 
  98. -     sys.path_hooks.append(path_hook)
  99. - 
  100.   vim.VIM_SPECIAL_PATH                    *python-VIM_SPECIAL_PATH*
  101.       String constant used in conjunction with vim path hook. If path hook 
  102.       installed by vim is requested to handle anything but path equal to 
  103. --- 363,368 ----
  104. ***************
  105. *** 402,409 ****
  106.       You should not be using any of these directly except for vim.path_hook 
  107.       in case you need to do something with sys.meta_path. It is not 
  108.       guaranteed that any of the objects will exist in the future vim 
  109. !     versions. In fact, find_module methods do not exists 
  110. !     in python3.
  111.   
  112.   vim._get_paths                        *python-_get_paths*
  113.       Methods returning a list of paths which will be searched for by path 
  114. --- 378,384 ----
  115.       You should not be using any of these directly except for vim.path_hook 
  116.       in case you need to do something with sys.meta_path. It is not 
  117.       guaranteed that any of the objects will exist in the future vim 
  118. !     versions.
  119.   
  120.   vim._get_paths                        *python-_get_paths*
  121.       Methods returning a list of paths which will be searched for by path 
  122. *** ../vim-7.3.1173/src/if_py_both.h    2013-06-12 14:20:15.000000000 +0200
  123. --- src/if_py_both.h    2013-06-12 14:35:42.000000000 +0200
  124. ***************
  125. *** 60,65 ****
  126. --- 60,70 ----
  127.   static PyObject *vim_module;
  128.   static PyObject *vim_special_path_object;
  129.   
  130. + static PyObject *py_find_module;
  131. + static PyObject *py_load_module;
  132. + 
  133. + static PyObject *VimError;
  134. + 
  135.   /*
  136.    * obtain a lock on the Vim data structures
  137.    */
  138. ***************
  139. *** 393,400 ****
  140.       return 0;
  141.   }
  142.   
  143.   
  144. ! static PyObject *VimError;
  145.   
  146.   /* Check to see whether a Vim error has been reported, or a keyboard
  147.    * interrupt has been detected.
  148. --- 398,431 ----
  149.       return 0;
  150.   }
  151.   
  152. + typedef struct
  153. + {
  154. +     PyObject_HEAD
  155. +     PyObject    *module;
  156. + } LoaderObject;
  157. + static PyTypeObject LoaderType;
  158. + 
  159. +     static void
  160. + LoaderDestructor(LoaderObject *self)
  161. + {
  162. +     Py_DECREF(self->module);
  163. +     DESTRUCTOR_FINISH(self);
  164. + }
  165. + 
  166. +     static PyObject *
  167. + LoaderLoadModule(LoaderObject *self, PyObject *args UNUSED)
  168. + {
  169. +     PyObject    *r = self->module;
  170.   
  171. !     Py_INCREF(r);
  172. !     return r;
  173. ! }
  174. ! 
  175. ! static struct PyMethodDef LoaderMethods[] = {
  176. !     /* name,        function,                calling,    doc */
  177. !     {"load_module", (PyCFunction)LoaderLoadModule,    METH_VARARGS,    ""},
  178. !     { NULL,        NULL,                0,        NULL}
  179. ! };
  180.   
  181.   /* Check to see whether a Vim error has been reported, or a keyboard
  182.    * interrupt has been detected.
  183. ***************
  184. *** 925,930 ****
  185. --- 956,1105 ----
  186.       return r;
  187.   }
  188.   
  189. +     static PyObject *
  190. + call_load_module(char *name, int len, PyObject *find_module_result)
  191. + {
  192. +     PyObject    *fd, *pathname, *description;
  193. + 
  194. +     if (!PyTuple_Check(find_module_result)
  195. +         || PyTuple_GET_SIZE(find_module_result) != 3)
  196. +     {
  197. +     PyErr_SetString(PyExc_TypeError,
  198. +         _("expected 3-tuple as imp.find_module() result"));
  199. +     return NULL;
  200. +     }
  201. + 
  202. +     if (!(fd = PyTuple_GET_ITEM(find_module_result, 0))
  203. +         || !(pathname = PyTuple_GET_ITEM(find_module_result, 1))
  204. +         || !(description = PyTuple_GET_ITEM(find_module_result, 2)))
  205. +     {
  206. +     PyErr_SetString(PyExc_RuntimeError,
  207. +         _("internal error: imp.find_module returned tuple with NULL"));
  208. +     return NULL;
  209. +     }
  210. + 
  211. +     return PyObject_CallFunction(py_load_module,
  212. +         "s#OOO", name, len, fd, pathname, description);
  213. + }
  214. + 
  215. +     static PyObject *
  216. + find_module(char *fullname, char *tail, PyObject *new_path)
  217. + {
  218. +     PyObject    *find_module_result;
  219. +     PyObject    *module;
  220. +     char    *dot;
  221. + 
  222. +     if ((dot = (char *) vim_strchr((char_u *) tail, '.')))
  223. +     {
  224. +     /*
  225. +      * There is a dot in the name: call find_module recursively without the 
  226. +      * first component
  227. +      */
  228. +     PyObject    *newest_path;
  229. +     int        partlen = (int) (dot - 1 - tail);
  230. + 
  231. +     if (!(find_module_result = PyObject_CallFunction(py_find_module,
  232. +             "s#O", tail, partlen, new_path)))
  233. +         return NULL;
  234. + 
  235. +     if (!(module = call_load_module(
  236. +             fullname,
  237. +             ((int) (tail - fullname)) + partlen,
  238. +             find_module_result)))
  239. +     {
  240. +         Py_DECREF(find_module_result);
  241. +         return NULL;
  242. +     }
  243. + 
  244. +     Py_DECREF(find_module_result);
  245. + 
  246. +     if (!(newest_path = PyObject_GetAttrString(module, "__path__")))
  247. +     {
  248. +         Py_DECREF(module);
  249. +         return NULL;
  250. +     }
  251. + 
  252. +     Py_DECREF(module);
  253. + 
  254. +     module = find_module(fullname, dot + 1, newest_path);
  255. + 
  256. +     Py_DECREF(newest_path);
  257. + 
  258. +     return module;
  259. +     }
  260. +     else
  261. +     {
  262. +     if (!(find_module_result = PyObject_CallFunction(py_find_module,
  263. +             "sO", tail, new_path)))
  264. +         return NULL;
  265. + 
  266. +     if (!(module = call_load_module(
  267. +             fullname,
  268. +             STRLEN(fullname),
  269. +             find_module_result)))
  270. +     {
  271. +         Py_DECREF(find_module_result);
  272. +         return NULL;
  273. +     }
  274. + 
  275. +     Py_DECREF(find_module_result);
  276. + 
  277. +     return module;
  278. +     }
  279. + }
  280. + 
  281. +     static PyObject *
  282. + FinderFindModule(PyObject *self, PyObject *args)
  283. + {
  284. +     char    *fullname;
  285. +     PyObject    *module;
  286. +     PyObject    *new_path;
  287. +     LoaderObject    *loader;
  288. + 
  289. +     if (!PyArg_ParseTuple(args, "s", &fullname))
  290. +     return NULL;
  291. + 
  292. +     if (!(new_path = Vim_GetPaths(self)))
  293. +     return NULL;
  294. + 
  295. +     module = find_module(fullname, fullname, new_path);
  296. + 
  297. +     Py_DECREF(new_path);
  298. + 
  299. +     if (!module)
  300. +     {
  301. +     Py_INCREF(Py_None);
  302. +     return Py_None;
  303. +     }
  304. + 
  305. +     if (!(loader = PyObject_NEW(LoaderObject, &LoaderType)))
  306. +     {
  307. +     Py_DECREF(module);
  308. +     return NULL;
  309. +     }
  310. + 
  311. +     loader->module = module;
  312. + 
  313. +     return (PyObject *) loader;
  314. + }
  315. + 
  316. +     static PyObject *
  317. + VimPathHook(PyObject *self UNUSED, PyObject *args)
  318. + {
  319. +     char    *path;
  320. + 
  321. +     if (PyArg_ParseTuple(args, "s", &path)
  322. +         && STRCMP(path, vim_special_path) == 0)
  323. +     {
  324. +     Py_INCREF(vim_module);
  325. +     return vim_module;
  326. +     }
  327. + 
  328. +     PyErr_Clear();
  329. +     PyErr_SetNone(PyExc_ImportError);
  330. +     return NULL;
  331. + }
  332. + 
  333.   /*
  334.    * Vim module - Definitions
  335.    */
  336. ***************
  337. *** 938,946 ****
  338.       {"chdir",        (PyCFunction)VimChdir,    METH_VARARGS|METH_KEYWORDS,    "Change directory"},
  339.       {"fchdir",        (PyCFunction)VimFchdir,    METH_VARARGS|METH_KEYWORDS,    "Change directory"},
  340.       {"foreach_rtp", VimForeachRTP,        METH_VARARGS,            "Call given callable for each path in &rtp"},
  341. - #if PY_MAJOR_VERSION < 3
  342.       {"find_module", FinderFindModule,        METH_VARARGS,            "Internal use only, returns loader object for any input it receives"},
  343. - #endif
  344.       {"path_hook",   VimPathHook,        METH_VARARGS,            "Hook function to install in sys.path_hooks"},
  345.       {"_get_paths",  (PyCFunction)Vim_GetPaths,    METH_NOARGS,            "Get &rtp-based additions to sys.path"},
  346.       { NULL,        NULL,            0,                NULL}
  347. --- 1113,1119 ----
  348. ***************
  349. *** 5188,5208 ****
  350.   } CurrentObject;
  351.   static PyTypeObject CurrentType;
  352.   
  353. - #if PY_MAJOR_VERSION >= 3
  354. - typedef struct
  355. - {
  356. -     PyObject_HEAD
  357. - } FinderObject;
  358. - static PyTypeObject FinderType;
  359. - #else
  360. - typedef struct
  361. - {
  362. -     PyObject_HEAD
  363. -     PyObject    *module;
  364. - } LoaderObject;
  365. - static PyTypeObject LoaderType;
  366. - #endif
  367. - 
  368.       static void
  369.   init_structs(void)
  370.   {
  371. --- 5361,5366 ----
  372. ***************
  373. *** 5418,5423 ****
  374. --- 5576,5589 ----
  375.       OptionsType.tp_traverse = (traverseproc)OptionsTraverse;
  376.       OptionsType.tp_clear = (inquiry)OptionsClear;
  377.   
  378. +     vim_memset(&LoaderType, 0, sizeof(LoaderType));
  379. +     LoaderType.tp_name = "vim.Loader";
  380. +     LoaderType.tp_basicsize = sizeof(LoaderObject);
  381. +     LoaderType.tp_flags = Py_TPFLAGS_DEFAULT;
  382. +     LoaderType.tp_doc = "vim message object";
  383. +     LoaderType.tp_methods = LoaderMethods;
  384. +     LoaderType.tp_dealloc = (destructor)LoaderDestructor;
  385. + 
  386.   #if PY_MAJOR_VERSION >= 3
  387.       vim_memset(&vimmodule, 0, sizeof(vimmodule));
  388.       vimmodule.m_name = "vim";
  389. ***************
  390. *** 5448,5458 ****
  391.       PYTYPE_READY(FunctionType);
  392.       PYTYPE_READY(OptionsType);
  393.       PYTYPE_READY(OutputType);
  394. - #if PY_MAJOR_VERSION >= 3
  395. -     PYTYPE_READY(FinderType);
  396. - #else
  397.       PYTYPE_READY(LoaderType);
  398. - #endif
  399.       return 0;
  400.   }
  401.   
  402. --- 5614,5620 ----
  403. ***************
  404. *** 5576,5586 ****
  405.       {"List",       (PyObject *)&ListType},
  406.       {"Function",   (PyObject *)&FunctionType},
  407.       {"Options",    (PyObject *)&OptionsType},
  408. ! #if PY_MAJOR_VERSION >= 3
  409. !     {"Finder",     (PyObject *)&FinderType},
  410. ! #else
  411. !     {"Loader",     (PyObject *)&LoaderType},
  412. ! #endif
  413.   };
  414.   
  415.   typedef int (*object_adder)(PyObject *, const char *, PyObject *);
  416. --- 5738,5744 ----
  417.       {"List",       (PyObject *)&ListType},
  418.       {"Function",   (PyObject *)&FunctionType},
  419.       {"Options",    (PyObject *)&OptionsType},
  420. !     {"_Loader",    (PyObject *)&LoaderType},
  421.   };
  422.   
  423.   typedef int (*object_adder)(PyObject *, const char *, PyObject *);
  424. ***************
  425. *** 5604,5609 ****
  426. --- 5762,5768 ----
  427.       int        i;
  428.       PyObject    *other_module;
  429.       PyObject    *attr;
  430. +     PyObject    *imp;
  431.   
  432.       for (i = 0; i < (int)(sizeof(numeric_constants)
  433.                          / sizeof(struct numeric_constant));
  434. ***************
  435. *** 5671,5685 ****
  436.   
  437.       ADD_OBJECT(m, "VIM_SPECIAL_PATH", vim_special_path_object);
  438.   
  439. ! #if PY_MAJOR_VERSION >= 3
  440. !     ADD_OBJECT(m, "_PathFinder", path_finder);
  441. !     ADD_CHECKED_OBJECT(m, "_find_module",
  442. !         (py_find_module = PyObject_GetAttrString(path_finder,
  443. !                              "find_module")));
  444. ! #else
  445.       ADD_OBJECT(m, "_find_module", py_find_module);
  446.       ADD_OBJECT(m, "_load_module", py_load_module);
  447. - #endif
  448.   
  449.       return 0;
  450.   }
  451. --- 5830,5855 ----
  452.   
  453.       ADD_OBJECT(m, "VIM_SPECIAL_PATH", vim_special_path_object);
  454.   
  455. !     if (!(imp = PyImport_ImportModule("imp")))
  456. !     return -1;
  457. ! 
  458. !     if (!(py_find_module = PyObject_GetAttrString(imp, "find_module")))
  459. !     {
  460. !     Py_DECREF(imp);
  461. !     return -1;
  462. !     }
  463. ! 
  464. !     if (!(py_load_module = PyObject_GetAttrString(imp, "load_module")))
  465. !     {
  466. !     Py_DECREF(py_find_module);
  467. !     Py_DECREF(imp);
  468. !     return -1;
  469. !     }
  470. ! 
  471. !     Py_DECREF(imp);
  472. ! 
  473.       ADD_OBJECT(m, "_find_module", py_find_module);
  474.       ADD_OBJECT(m, "_load_module", py_load_module);
  475.   
  476.       return 0;
  477.   }
  478. *** ../vim-7.3.1173/src/if_python3.c    2013-06-10 21:27:18.000000000 +0200
  479. --- src/if_python3.c    2013-06-12 14:36:00.000000000 +0200
  480. ***************
  481. *** 175,180 ****
  482. --- 175,181 ----
  483.   # define PyObject_HasAttrString py3_PyObject_HasAttrString
  484.   # define PyObject_SetAttrString py3_PyObject_SetAttrString
  485.   # define PyObject_CallFunctionObjArgs py3_PyObject_CallFunctionObjArgs
  486. + # define _PyObject_CallFunction_SizeT py3__PyObject_CallFunction_SizeT
  487.   # define PyObject_Call py3_PyObject_Call
  488.   # define PyEval_GetLocals py3_PyEval_GetLocals
  489.   # define PyEval_GetGlobals py3_PyEval_GetGlobals
  490. ***************
  491. *** 296,301 ****
  492. --- 297,303 ----
  493.   static int (*py3_PyObject_HasAttrString)(PyObject *, const char *);
  494.   static PyObject* (*py3_PyObject_SetAttrString)(PyObject *, const char *, PyObject *);
  495.   static PyObject* (*py3_PyObject_CallFunctionObjArgs)(PyObject *, ...);
  496. + static PyObject* (*py3__PyObject_CallFunction_SizeT)(PyObject *, char *, ...);
  497.   static PyObject* (*py3_PyObject_Call)(PyObject *, PyObject *, PyObject *);
  498.   static PyObject* (*py3_PyEval_GetGlobals)();
  499.   static PyObject* (*py3_PyEval_GetLocals)();
  500. ***************
  501. *** 458,463 ****
  502. --- 460,466 ----
  503.       {"PyObject_HasAttrString", (PYTHON_PROC*)&py3_PyObject_HasAttrString},
  504.       {"PyObject_SetAttrString", (PYTHON_PROC*)&py3_PyObject_SetAttrString},
  505.       {"PyObject_CallFunctionObjArgs", (PYTHON_PROC*)&py3_PyObject_CallFunctionObjArgs},
  506. +     {"_PyObject_CallFunction_SizeT", (PYTHON_PROC*)&py3__PyObject_CallFunction_SizeT},
  507.       {"PyObject_Call", (PYTHON_PROC*)&py3_PyObject_Call},
  508.       {"PyEval_GetGlobals", (PYTHON_PROC*)&py3_PyEval_GetGlobals},
  509.       {"PyEval_GetLocals", (PYTHON_PROC*)&py3_PyEval_GetLocals},
  510. ***************
  511. *** 740,748 ****
  512.   
  513.   static struct PyModuleDef vimmodule;
  514.   
  515. - static PyObject *path_finder;
  516. - static PyObject *py_find_module = NULL;
  517. - 
  518.   #define PY_CAN_RECURSE
  519.   
  520.   /*
  521. --- 743,748 ----
  522. ***************
  523. *** 1603,1672 ****
  524.   #endif
  525.   
  526.       static PyObject *
  527. - VimPathHook(PyObject *self UNUSED, PyObject *args)
  528. - {
  529. -     char    *path;
  530. - 
  531. -     if (PyArg_ParseTuple(args, "s", &path)
  532. -         && STRCMP(path, vim_special_path) == 0)
  533. -     {
  534. -     Py_INCREF(&FinderType);
  535. -     return (PyObject *) &FinderType;
  536. -     }
  537. - 
  538. -     PyErr_Clear();
  539. -     PyErr_SetNone(PyExc_ImportError);
  540. -     return NULL;
  541. - }
  542. - 
  543. -     static PyObject *
  544. - FinderFindModule(PyObject *cls UNUSED, PyObject *fullname)
  545. - {
  546. -     PyObject    *new_path;
  547. -     PyObject    *r;
  548. - 
  549. -     if (!(new_path = Vim_GetPaths(NULL)))
  550. -     return NULL;
  551. - 
  552. -     /* call find_module of the super() class */
  553. -     r = PyObject_CallFunctionObjArgs(py_find_module, fullname, new_path, NULL);
  554. - 
  555. -     Py_DECREF(new_path);
  556. - 
  557. -     return r;
  558. - }
  559. - 
  560. - static struct PyMethodDef FinderMethods[] = {
  561. -     {"find_module",    FinderFindModule,    METH_CLASS|METH_O,    ""},
  562. -     {NULL,        NULL,            0,            NULL}
  563. - };
  564. - 
  565. -     static PyObject *
  566.   Py3Init_vim(void)
  567.   {
  568.       /* The special value is removed from sys.path in Python3_Init(). */
  569.       static wchar_t *(argv[2]) = {L"/must>not&exist/foo", NULL};
  570. -     PyObject    *importlib_machinery;
  571. - 
  572. -     if (!(importlib_machinery = PyImport_ImportModule("importlib.machinery")))
  573. -     return NULL;
  574. - 
  575. -     if (!(path_finder = PyObject_GetAttrString(importlib_machinery,
  576. -                            "PathFinder")))
  577. -     {
  578. -     Py_DECREF(importlib_machinery);
  579. -     return NULL;
  580. -     }
  581. - 
  582. -     Py_DECREF(importlib_machinery);
  583. - 
  584. -     vim_memset(&FinderType, 0, sizeof(FinderObject));
  585. -     FinderType.tp_name = "vim.Finder";
  586. -     FinderType.tp_basicsize = sizeof(FinderObject);
  587. -     FinderType.tp_base = (PyTypeObject *) path_finder;
  588. -     FinderType.tp_flags = Py_TPFLAGS_DEFAULT;
  589. -     FinderType.tp_doc = "Vim finder class, for use with path hook";
  590. -     FinderType.tp_methods = FinderMethods;
  591.   
  592.       if (init_types())
  593.       return NULL;
  594. --- 1603,1612 ----
  595. *** ../vim-7.3.1173/src/if_python.c    2013-06-12 14:20:15.000000000 +0200
  596. --- src/if_python.c    2013-06-12 14:35:49.000000000 +0200
  597. ***************
  598. *** 752,763 ****
  599.   static PyObject *ListGetattr(PyObject *, char *);
  600.   static PyObject *FunctionGetattr(PyObject *, char *);
  601.   
  602. - static PyObject *FinderFindModule(PyObject *, PyObject *);
  603. - static PyObject *VimPathHook(PyObject *, PyObject *);
  604. - 
  605. - static PyObject *py_find_module;
  606. - static PyObject *py_load_module;
  607. - 
  608.   #ifndef Py_VISIT
  609.   # define Py_VISIT(obj) visit(obj, arg)
  610.   #endif
  611. --- 752,757 ----
  612. ***************
  613. *** 1382,1585 ****
  614.   }
  615.   #endif
  616.   
  617. -     static void
  618. - LoaderDestructor(LoaderObject *self)
  619. - {
  620. -     Py_DECREF(self->module);
  621. -     DESTRUCTOR_FINISH(self);
  622. - }
  623. - 
  624. -     static PyObject *
  625. - LoaderLoadModule(LoaderObject *self, PyObject *args UNUSED)
  626. - {
  627. -     PyObject    *r = self->module;
  628. - 
  629. -     Py_INCREF(r);
  630. -     return r;
  631. - }
  632. - 
  633. - static struct PyMethodDef LoaderMethods[] = {
  634. -     /* name,        function,                calling,    doc */
  635. -     {"load_module", (PyCFunction)LoaderLoadModule,    METH_VARARGS,    ""},
  636. -     { NULL,        NULL,                0,        NULL}
  637. - };
  638. - 
  639. -     static PyObject *
  640. - call_load_module(char *name, int len, PyObject *find_module_result)
  641. - {
  642. -     PyObject    *fd, *pathname, *description;
  643. - 
  644. -     if (!PyTuple_Check(find_module_result)
  645. -         || PyTuple_GET_SIZE(find_module_result) != 3)
  646. -     {
  647. -     PyErr_SetString(PyExc_TypeError,
  648. -         _("expected 3-tuple as imp.find_module() result"));
  649. -     return NULL;
  650. -     }
  651. - 
  652. -     if (!(fd = PyTuple_GET_ITEM(find_module_result, 0))
  653. -         || !(pathname = PyTuple_GET_ITEM(find_module_result, 1))
  654. -         || !(description = PyTuple_GET_ITEM(find_module_result, 2)))
  655. -     {
  656. -     PyErr_SetString(PyExc_RuntimeError,
  657. -         _("internal error: imp.find_module returned tuple with NULL"));
  658. -     return NULL;
  659. -     }
  660. - 
  661. -     return PyObject_CallFunction(py_load_module,
  662. -         "s#OOO", name, len, fd, pathname, description);
  663. - }
  664. - 
  665. -     static PyObject *
  666. - find_module(char *fullname, char *tail, PyObject *new_path)
  667. - {
  668. -     PyObject    *find_module_result;
  669. -     PyObject    *module;
  670. -     char    *dot;
  671. - 
  672. -     if ((dot = (char *) vim_strchr((char_u *) tail, '.')))
  673. -     {
  674. -     /*
  675. -      * There is a dot in the name: call find_module recursively without the 
  676. -      * first component
  677. -      */
  678. -     PyObject    *newest_path;
  679. -     int        partlen = (int) (dot - 1 - tail);
  680. - 
  681. -     if (!(find_module_result = PyObject_CallFunction(py_find_module,
  682. -             "s#O", tail, partlen, new_path)))
  683. -         return NULL;
  684. - 
  685. -     if (!(module = call_load_module(
  686. -             fullname,
  687. -             ((int) (tail - fullname)) + partlen,
  688. -             find_module_result)))
  689. -     {
  690. -         Py_DECREF(find_module_result);
  691. -         return NULL;
  692. -     }
  693. - 
  694. -     Py_DECREF(find_module_result);
  695. - 
  696. -     if (!(newest_path = PyObject_GetAttrString(module, "__path__")))
  697. -     {
  698. -         Py_DECREF(module);
  699. -         return NULL;
  700. -     }
  701. - 
  702. -     Py_DECREF(module);
  703. - 
  704. -     module = find_module(fullname, dot + 1, newest_path);
  705. - 
  706. -     Py_DECREF(newest_path);
  707. - 
  708. -     return module;
  709. -     }
  710. -     else
  711. -     {
  712. -     if (!(find_module_result = PyObject_CallFunction(py_find_module,
  713. -             "sO", tail, new_path)))
  714. -         return NULL;
  715. - 
  716. -     if (!(module = call_load_module(
  717. -             fullname,
  718. -             STRLEN(fullname),
  719. -             find_module_result)))
  720. -     {
  721. -         Py_DECREF(find_module_result);
  722. -         return NULL;
  723. -     }
  724. - 
  725. -     Py_DECREF(find_module_result);
  726. - 
  727. -     return module;
  728. -     }
  729. - }
  730. - 
  731. -     static PyObject *
  732. - FinderFindModule(PyObject *self, PyObject *args)
  733. - {
  734. -     char    *fullname;
  735. -     PyObject    *module;
  736. -     PyObject    *new_path;
  737. -     LoaderObject    *loader;
  738. - 
  739. -     if (!PyArg_ParseTuple(args, "s", &fullname))
  740. -     return NULL;
  741. - 
  742. -     if (!(new_path = Vim_GetPaths(self)))
  743. -     return NULL;
  744. - 
  745. -     module = find_module(fullname, fullname, new_path);
  746. - 
  747. -     Py_DECREF(new_path);
  748. - 
  749. -     if (!module)
  750. -     {
  751. -     Py_INCREF(Py_None);
  752. -     return Py_None;
  753. -     }
  754. - 
  755. -     if (!(loader = PyObject_NEW(LoaderObject, &LoaderType)))
  756. -     {
  757. -     Py_DECREF(module);
  758. -     return NULL;
  759. -     }
  760. - 
  761. -     loader->module = module;
  762. - 
  763. -     return (PyObject *) loader;
  764. - }
  765. - 
  766. -     static PyObject *
  767. - VimPathHook(PyObject *self UNUSED, PyObject *args)
  768. - {
  769. -     char    *path;
  770. - 
  771. -     if (PyArg_ParseTuple(args, "s", &path)
  772. -         && STRCMP(path, vim_special_path) == 0)
  773. -     {
  774. -     Py_INCREF(vim_module);
  775. -     return vim_module;
  776. -     }
  777. - 
  778. -     PyErr_Clear();
  779. -     PyErr_SetNone(PyExc_ImportError);
  780. -     return NULL;
  781. - }
  782. - 
  783.       static int
  784.   PythonMod_Init(void)
  785.   {
  786.       /* The special value is removed from sys.path in Python_Init(). */
  787.       static char    *(argv[2]) = {"/must>not&exist/foo", NULL};
  788. -     PyObject    *imp;
  789. - 
  790. -     if (!(imp = PyImport_ImportModule("imp")))
  791. -     return -1;
  792. - 
  793. -     if (!(py_find_module = PyObject_GetAttrString(imp, "find_module")))
  794. -     {
  795. -     Py_DECREF(imp);
  796. -     return -1;
  797. -     }
  798. - 
  799. -     if (!(py_load_module = PyObject_GetAttrString(imp, "load_module")))
  800. -     {
  801. -     Py_DECREF(py_find_module);
  802. -     Py_DECREF(imp);
  803. -     return -1;
  804. -     }
  805. - 
  806. -     Py_DECREF(imp);
  807. - 
  808. -     vim_memset(&LoaderType, 0, sizeof(LoaderType));
  809. -     LoaderType.tp_name = "vim.Loader";
  810. -     LoaderType.tp_basicsize = sizeof(LoaderObject);
  811. -     LoaderType.tp_flags = Py_TPFLAGS_DEFAULT;
  812. -     LoaderType.tp_doc = "vim message object";
  813. -     LoaderType.tp_methods = LoaderMethods;
  814. -     LoaderType.tp_dealloc = (destructor)LoaderDestructor;
  815.   
  816.       if (init_types())
  817.       return -1;
  818. --- 1376,1386 ----
  819. *** ../vim-7.3.1173/src/version.c    2013-06-12 14:26:20.000000000 +0200
  820. --- src/version.c    2013-06-12 14:35:25.000000000 +0200
  821. ***************
  822. *** 730,731 ****
  823. --- 730,733 ----
  824.   {   /* Add new patch number below this line */
  825. + /**/
  826. +     1174,
  827.   /**/
  828.  
  829. -- 
  830. "Hit any key to continue" is very confusing when you have two keyboards.
  831.  
  832.  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
  833. ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
  834. \\\  an exciting new programming language -- http://www.Zimbu.org        ///
  835.  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///
  836.