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.220 < prev    next >
Encoding:
Internet Message Format  |  2012-11-20  |  36.7 KB
  1. To: vim_dev@googlegroups.com
  2. Subject: Patch 7.3.220
  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.220
  11. Problem:    Python 3: vim.error is a 'str' instead of an 'Exception' object,
  12.             so 'except' or 'raise' it causes a 'SystemError' exception.
  13.             Buffer objects do not support slice assignment.
  14.             When exchanging text between Vim and Python, multibyte texts become
  15.             gabage or cause Unicode Expceptions, etc.
  16.             'py3file' tries to read in the file as Unicode, sometimes causes
  17.             UnicodeDecodeException
  18. Solution:   Fix the problems. (lilydjwg)
  19. Files:      src/if_py_both.h, src/if_python.c, src/if_python3.c
  20.     
  21.  
  22. *** ../mercurial/vim73/src/if_py_both.h    2011-03-22 15:47:18.000000000 +0100
  23. --- src/if_py_both.h    2011-06-18 23:54:25.000000000 +0200
  24. ***************
  25. *** 65,74 ****
  26.   OutputWrite(PyObject *self, PyObject *args)
  27.   {
  28.       int len;
  29. !     char *str;
  30.       int error = ((OutputObject *)(self))->error;
  31.   
  32. !     if (!PyArg_ParseTuple(args, "s#", &str, &len))
  33.       return NULL;
  34.   
  35.       Py_BEGIN_ALLOW_THREADS
  36. --- 65,74 ----
  37.   OutputWrite(PyObject *self, PyObject *args)
  38.   {
  39.       int len;
  40. !     char *str = NULL;
  41.       int error = ((OutputObject *)(self))->error;
  42.   
  43. !     if (!PyArg_ParseTuple(args, "es#", p_enc, &str, &len))
  44.       return NULL;
  45.   
  46.       Py_BEGIN_ALLOW_THREADS
  47. ***************
  48. *** 76,81 ****
  49. --- 76,82 ----
  50.       writer((writefn)(error ? emsg : msg), (char_u *)str, len);
  51.       Python_Release_Vim();
  52.       Py_END_ALLOW_THREADS
  53. +     PyMem_Free(str);
  54.   
  55.       Py_INCREF(Py_None);
  56.       return Py_None;
  57. ***************
  58. *** 104,113 ****
  59.       for (i = 0; i < n; ++i)
  60.       {
  61.       PyObject *line = PyList_GetItem(list, i);
  62. !     char *str;
  63.       PyInt len;
  64.   
  65. !     if (!PyArg_Parse(line, "s#", &str, &len)) {
  66.           PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
  67.           Py_DECREF(list);
  68.           return NULL;
  69. --- 105,114 ----
  70.       for (i = 0; i < n; ++i)
  71.       {
  72.       PyObject *line = PyList_GetItem(list, i);
  73. !     char *str = NULL;
  74.       PyInt len;
  75.   
  76. !     if (!PyArg_Parse(line, "es#", p_enc, &str, &len)) {
  77.           PyErr_SetString(PyExc_TypeError, _("writelines() requires list of strings"));
  78.           Py_DECREF(list);
  79.           return NULL;
  80. ***************
  81. *** 118,123 ****
  82. --- 119,125 ----
  83.       writer((writefn)(error ? emsg : msg), (char_u *)str, len);
  84.       Python_Release_Vim();
  85.       Py_END_ALLOW_THREADS
  86. +     PyMem_Free(str);
  87.       }
  88.   
  89.       Py_DECREF(list);
  90. ***************
  91. *** 681,686 ****
  92. --- 683,689 ----
  93.   {
  94.       const char *str;
  95.       char *save;
  96. +     PyObject *bytes;
  97.       PyInt len;
  98.       PyInt i;
  99.       char *p;
  100. ***************
  101. *** 691,698 ****
  102.       return NULL;
  103.       }
  104.   
  105. !     str = PyString_AsString(obj);
  106. !     len = PyString_Size(obj);
  107.   
  108.       /*
  109.        * Error checking: String must not contain newlines, as we
  110. --- 694,702 ----
  111.       return NULL;
  112.       }
  113.   
  114. !     bytes = PyString_AsBytes(obj);  /* for Python 2 this does nothing */
  115. !     str = PyString_AsString(bytes);
  116. !     len = PyString_Size(bytes);
  117.   
  118.       /*
  119.        * Error checking: String must not contain newlines, as we
  120. ***************
  121. *** 731,736 ****
  122. --- 735,741 ----
  123.       }
  124.   
  125.       save[i] = '\0';
  126. +     PyString_FreeBytes(bytes);  /* Python 2 does nothing here */
  127.   
  128.       return save;
  129.   }
  130. ***************
  131. *** 817,823 ****
  132.       invalidate_botline();
  133.   }
  134.   
  135. ! /* Replace a line in the specified buffer. The line number is
  136.    * in Vim format (1-based). The replacement line is given as
  137.    * a Python string object. The object is checked for validity
  138.    * and correct format. Errors are returned as a value of FAIL.
  139. --- 822,829 ----
  140.       invalidate_botline();
  141.   }
  142.   
  143. ! /*
  144. !  * Replace a line in the specified buffer. The line number is
  145.    * in Vim format (1-based). The replacement line is given as
  146.    * a Python string object. The object is checked for validity
  147.    * and correct format. Errors are returned as a value of FAIL.
  148. ***************
  149. *** 908,913 ****
  150. --- 914,1106 ----
  151.       }
  152.   }
  153.   
  154. + /* Replace a range of lines in the specified buffer. The line numbers are in
  155. +  * Vim format (1-based). The range is from lo up to, but not including, hi.
  156. +  * The replacement lines are given as a Python list of string objects. The
  157. +  * list is checked for validity and correct format. Errors are returned as a
  158. +  * value of FAIL.  The return value is OK on success.
  159. +  * If OK is returned and len_change is not NULL, *len_change
  160. +  * is set to the change in the buffer length.
  161. +  */
  162. +     static int
  163. + SetBufferLineList(buf_T *buf, PyInt lo, PyInt hi, PyObject *list, PyInt *len_change)
  164. + {
  165. +     /* First of all, we check the thpe of the supplied Python object.
  166. +      * There are three cases:
  167. +      *      1. NULL, or None - this is a deletion.
  168. +      *      2. A list       - this is a replacement.
  169. +      *      3. Anything else - this is an error.
  170. +      */
  171. +     if (list == Py_None || list == NULL)
  172. +     {
  173. +     PyInt    i;
  174. +     PyInt    n = (int)(hi - lo);
  175. +     buf_T    *savebuf = curbuf;
  176. + 
  177. +     PyErr_Clear();
  178. +     curbuf = buf;
  179. + 
  180. +     if (u_savedel((linenr_T)lo, (long)n) == FAIL)
  181. +         PyErr_SetVim(_("cannot save undo information"));
  182. +     else
  183. +     {
  184. +         for (i = 0; i < n; ++i)
  185. +         {
  186. +         if (ml_delete((linenr_T)lo, FALSE) == FAIL)
  187. +         {
  188. +             PyErr_SetVim(_("cannot delete line"));
  189. +             break;
  190. +         }
  191. +         }
  192. +         if (buf == curwin->w_buffer)
  193. +         py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)-n);
  194. +         deleted_lines_mark((linenr_T)lo, (long)i);
  195. +     }
  196. + 
  197. +     curbuf = savebuf;
  198. + 
  199. +     if (PyErr_Occurred() || VimErrorCheck())
  200. +         return FAIL;
  201. + 
  202. +     if (len_change)
  203. +         *len_change = -n;
  204. + 
  205. +     return OK;
  206. +     }
  207. +     else if (PyList_Check(list))
  208. +     {
  209. +     PyInt    i;
  210. +     PyInt    new_len = PyList_Size(list);
  211. +     PyInt    old_len = hi - lo;
  212. +     PyInt    extra = 0;    /* lines added to text, can be negative */
  213. +     char    **array;
  214. +     buf_T    *savebuf;
  215. + 
  216. +     if (new_len == 0)    /* avoid allocating zero bytes */
  217. +         array = NULL;
  218. +     else
  219. +     {
  220. +         array = (char **)alloc((unsigned)(new_len * sizeof(char *)));
  221. +         if (array == NULL)
  222. +         {
  223. +         PyErr_NoMemory();
  224. +         return FAIL;
  225. +         }
  226. +     }
  227. + 
  228. +     for (i = 0; i < new_len; ++i)
  229. +     {
  230. +         PyObject *line = PyList_GetItem(list, i);
  231. + 
  232. +         array[i] = StringToLine(line);
  233. +         if (array[i] == NULL)
  234. +         {
  235. +         while (i)
  236. +             vim_free(array[--i]);
  237. +         vim_free(array);
  238. +         return FAIL;
  239. +         }
  240. +     }
  241. + 
  242. +     savebuf = curbuf;
  243. + 
  244. +     PyErr_Clear();
  245. +     curbuf = buf;
  246. + 
  247. +     if (u_save((linenr_T)(lo-1), (linenr_T)hi) == FAIL)
  248. +         PyErr_SetVim(_("cannot save undo information"));
  249. + 
  250. +     /* If the size of the range is reducing (ie, new_len < old_len) we
  251. +      * need to delete some old_len. We do this at the start, by
  252. +      * repeatedly deleting line "lo".
  253. +      */
  254. +     if (!PyErr_Occurred())
  255. +     {
  256. +         for (i = 0; i < old_len - new_len; ++i)
  257. +         if (ml_delete((linenr_T)lo, FALSE) == FAIL)
  258. +         {
  259. +             PyErr_SetVim(_("cannot delete line"));
  260. +             break;
  261. +         }
  262. +         extra -= i;
  263. +     }
  264. + 
  265. +     /* For as long as possible, replace the existing old_len with the
  266. +      * new old_len. This is a more efficient operation, as it requires
  267. +      * less memory allocation and freeing.
  268. +      */
  269. +     if (!PyErr_Occurred())
  270. +     {
  271. +         for (i = 0; i < old_len && i < new_len; ++i)
  272. +         if (ml_replace((linenr_T)(lo+i), (char_u *)array[i], FALSE)
  273. +                                       == FAIL)
  274. +         {
  275. +             PyErr_SetVim(_("cannot replace line"));
  276. +             break;
  277. +         }
  278. +     }
  279. +     else
  280. +         i = 0;
  281. + 
  282. +     /* Now we may need to insert the remaining new old_len. If we do, we
  283. +      * must free the strings as we finish with them (we can't pass the
  284. +      * responsibility to vim in this case).
  285. +      */
  286. +     if (!PyErr_Occurred())
  287. +     {
  288. +         while (i < new_len)
  289. +         {
  290. +         if (ml_append((linenr_T)(lo + i - 1),
  291. +                     (char_u *)array[i], 0, FALSE) == FAIL)
  292. +         {
  293. +             PyErr_SetVim(_("cannot insert line"));
  294. +             break;
  295. +         }
  296. +         vim_free(array[i]);
  297. +         ++i;
  298. +         ++extra;
  299. +         }
  300. +     }
  301. + 
  302. +     /* Free any left-over old_len, as a result of an error */
  303. +     while (i < new_len)
  304. +     {
  305. +         vim_free(array[i]);
  306. +         ++i;
  307. +     }
  308. + 
  309. +     /* Free the array of old_len. All of its contents have now
  310. +      * been dealt with (either freed, or the responsibility passed
  311. +      * to vim.
  312. +      */
  313. +     vim_free(array);
  314. + 
  315. +     /* Adjust marks. Invalidate any which lie in the
  316. +      * changed range, and move any in the remainder of the buffer.
  317. +      */
  318. +     mark_adjust((linenr_T)lo, (linenr_T)(hi - 1),
  319. +                           (long)MAXLNUM, (long)extra);
  320. +     changed_lines((linenr_T)lo, 0, (linenr_T)hi, (long)extra);
  321. + 
  322. +     if (buf == curwin->w_buffer)
  323. +         py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)extra);
  324. + 
  325. +     curbuf = savebuf;
  326. + 
  327. +     if (PyErr_Occurred() || VimErrorCheck())
  328. +         return FAIL;
  329. + 
  330. +     if (len_change)
  331. +         *len_change = new_len - old_len;
  332. + 
  333. +     return OK;
  334. +     }
  335. +     else
  336. +     {
  337. +     PyErr_BadArgument();
  338. +     return FAIL;
  339. +     }
  340. + }
  341.   
  342.   /* Insert a number of lines into the specified buffer after the specifed line.
  343.    * The line number is in Vim format (1-based). The lines to be inserted are
  344. ***************
  345. *** 1108,1113 ****
  346. --- 1301,1340 ----
  347.       return -1;
  348.   
  349.       if (new_end)
  350. +     *new_end = end + len_change;
  351. + 
  352. +     return 0;
  353. + }
  354. + 
  355. +     static PyInt
  356. + RBAsSlice(BufferObject *self, PyInt lo, PyInt hi, PyObject *val, PyInt start, PyInt end, PyInt *new_end)
  357. + {
  358. +     PyInt size;
  359. +     PyInt len_change;
  360. + 
  361. +     /* Self must be a valid buffer */
  362. +     if (CheckBuffer(self))
  363. +     return -1;
  364. + 
  365. +     /* Sort out the slice range */
  366. +     size = end - start + 1;
  367. + 
  368. +     if (lo < 0)
  369. +     lo = 0;
  370. +     else if (lo > size)
  371. +     lo = size;
  372. +     if (hi < 0)
  373. +     hi = 0;
  374. +     if (hi < lo)
  375. +     hi = lo;
  376. +     else if (hi > size)
  377. +     hi = size;
  378. + 
  379. +     if (SetBufferLineList(self->buf, lo + start, hi + start,
  380. +                             val, &len_change) == FAIL)
  381. +     return -1;
  382. + 
  383. +     if (new_end)
  384.       *new_end = end + len_change;
  385.   
  386.       return 0;
  387. *** ../mercurial/vim73/src/if_python.c    2011-03-26 18:32:00.000000000 +0100
  388. --- src/if_python.c    2011-06-19 00:02:15.000000000 +0200
  389. ***************
  390. *** 56,61 ****
  391. --- 56,65 ----
  392.   
  393.   static void init_structs(void);
  394.   
  395. + /* No-op conversion functions, use with care! */
  396. + #define PyString_AsBytes(obj) (obj)
  397. + #define PyString_FreeBytes(obj)
  398. + 
  399.   #if !defined(FEAT_PYTHON) && defined(PROTO)
  400.   /* Use this to be able to generate prototypes without python being used. */
  401.   # define PyObject Py_ssize_t
  402. ***************
  403. *** 129,134 ****
  404. --- 133,139 ----
  405.    */
  406.   # define PyArg_Parse dll_PyArg_Parse
  407.   # define PyArg_ParseTuple dll_PyArg_ParseTuple
  408. + # define PyMem_Free dll_PyMem_Free
  409.   # define PyDict_SetItemString dll_PyDict_SetItemString
  410.   # define PyErr_BadArgument dll_PyErr_BadArgument
  411.   # define PyErr_Clear dll_PyErr_Clear
  412. ***************
  413. *** 189,194 ****
  414. --- 194,200 ----
  415.    */
  416.   static int(*dll_PyArg_Parse)(PyObject *, char *, ...);
  417.   static int(*dll_PyArg_ParseTuple)(PyObject *, char *, ...);
  418. + static int(*dll_PyMem_Free)(void *);
  419.   static int(*dll_PyDict_SetItemString)(PyObject *dp, char *key, PyObject *item);
  420.   static int(*dll_PyErr_BadArgument)(void);
  421.   static void(*dll_PyErr_Clear)(void);
  422. ***************
  423. *** 271,276 ****
  424. --- 277,283 ----
  425.   {
  426.       {"PyArg_Parse", (PYTHON_PROC*)&dll_PyArg_Parse},
  427.       {"PyArg_ParseTuple", (PYTHON_PROC*)&dll_PyArg_ParseTuple},
  428. +     {"PyMem_Free", (PYTHON_PROC*)&dll_PyMem_Free},
  429.       {"PyDict_SetItemString", (PYTHON_PROC*)&dll_PyDict_SetItemString},
  430.       {"PyErr_BadArgument", (PYTHON_PROC*)&dll_PyErr_BadArgument},
  431.       {"PyErr_Clear", (PYTHON_PROC*)&dll_PyErr_Clear},
  432. ***************
  433. *** 833,876 ****
  434.   static PyObject *CurrentGetattr(PyObject *, char *);
  435.   static int CurrentSetattr(PyObject *, char *, PyObject *);
  436.   
  437. - /* Common routines for buffers and line ranges
  438. -  * -------------------------------------------
  439. -  */
  440. - 
  441. -     static PyInt
  442. - RBAssSlice(BufferObject *self, PyInt lo, PyInt hi, PyObject *val, PyInt start, PyInt end, PyInt *new_end)
  443. - {
  444. -     PyInt size;
  445. -     PyInt len_change;
  446. - 
  447. -     /* Self must be a valid buffer */
  448. -     if (CheckBuffer(self))
  449. -     return -1;
  450. - 
  451. -     /* Sort out the slice range */
  452. -     size = end - start + 1;
  453. - 
  454. -     if (lo < 0)
  455. -     lo = 0;
  456. -     else if (lo > size)
  457. -     lo = size;
  458. -     if (hi < 0)
  459. -     hi = 0;
  460. -     if (hi < lo)
  461. -     hi = lo;
  462. -     else if (hi > size)
  463. -     hi = size;
  464. - 
  465. -     if (SetBufferLineList(self->buf, lo + start, hi + start,
  466. -                             val, &len_change) == FAIL)
  467. -     return -1;
  468. - 
  469. -     if (new_end)
  470. -     *new_end = end + len_change;
  471. - 
  472. -     return 0;
  473. - }
  474. - 
  475.   static PySequenceMethods BufferAsSeq = {
  476.       (PyInquiry)        BufferLength,        /* sq_length,    len(x)   */
  477.       (binaryfunc)    0, /* BufferConcat, */         /* sq_concat,    x+y      */
  478. --- 840,845 ----
  479. ***************
  480. *** 1038,1044 ****
  481.       static PyInt
  482.   BufferAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
  483.   {
  484. !     return RBAssSlice((BufferObject *)(self), lo, hi, val, 1,
  485.                 (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
  486.                 NULL);
  487.   }
  488. --- 1007,1013 ----
  489.       static PyInt
  490.   BufferAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
  491.   {
  492. !     return RBAsSlice((BufferObject *)(self), lo, hi, val, 1,
  493.                 (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
  494.                 NULL);
  495.   }
  496. ***************
  497. *** 1088,1094 ****
  498.       static PyInt
  499.   RangeAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
  500.   {
  501. !     return RBAssSlice(((RangeObject *)(self))->buf, lo, hi, val,
  502.                 ((RangeObject *)(self))->start,
  503.                 ((RangeObject *)(self))->end,
  504.                 &((RangeObject *)(self))->end);
  505. --- 1057,1063 ----
  506.       static PyInt
  507.   RangeAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
  508.   {
  509. !     return RBAsSlice(((RangeObject *)(self))->buf, lo, hi, val,
  510.                 ((RangeObject *)(self))->start,
  511.                 ((RangeObject *)(self))->end,
  512.                 &((RangeObject *)(self))->end);
  513. ***************
  514. *** 1435,1628 ****
  515.    * 4. Utility functions for handling the interface between Vim and Python.
  516.    */
  517.   
  518. - /* Replace a range of lines in the specified buffer. The line numbers are in
  519. -  * Vim format (1-based). The range is from lo up to, but not including, hi.
  520. -  * The replacement lines are given as a Python list of string objects. The
  521. -  * list is checked for validity and correct format. Errors are returned as a
  522. -  * value of FAIL.  The return value is OK on success.
  523. -  * If OK is returned and len_change is not NULL, *len_change
  524. -  * is set to the change in the buffer length.
  525. -  */
  526. -     static int
  527. - SetBufferLineList(buf_T *buf, PyInt lo, PyInt hi, PyObject *list, PyInt *len_change)
  528. - {
  529. -     /* First of all, we check the thpe of the supplied Python object.
  530. -      * There are three cases:
  531. -      *      1. NULL, or None - this is a deletion.
  532. -      *      2. A list       - this is a replacement.
  533. -      *      3. Anything else - this is an error.
  534. -      */
  535. -     if (list == Py_None || list == NULL)
  536. -     {
  537. -     PyInt    i;
  538. -     PyInt    n = (int)(hi - lo);
  539. -     buf_T    *savebuf = curbuf;
  540. - 
  541. -     PyErr_Clear();
  542. -     curbuf = buf;
  543. - 
  544. -     if (u_savedel((linenr_T)lo, (long)n) == FAIL)
  545. -         PyErr_SetVim(_("cannot save undo information"));
  546. -     else
  547. -     {
  548. -         for (i = 0; i < n; ++i)
  549. -         {
  550. -         if (ml_delete((linenr_T)lo, FALSE) == FAIL)
  551. -         {
  552. -             PyErr_SetVim(_("cannot delete line"));
  553. -             break;
  554. -         }
  555. -         }
  556. -         if (buf == curwin->w_buffer)
  557. -         py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)-n);
  558. -         deleted_lines_mark((linenr_T)lo, (long)i);
  559. -     }
  560. - 
  561. -     curbuf = savebuf;
  562. - 
  563. -     if (PyErr_Occurred() || VimErrorCheck())
  564. -         return FAIL;
  565. - 
  566. -     if (len_change)
  567. -         *len_change = -n;
  568. - 
  569. -     return OK;
  570. -     }
  571. -     else if (PyList_Check(list))
  572. -     {
  573. -     PyInt    i;
  574. -     PyInt    new_len = PyList_Size(list);
  575. -     PyInt    old_len = hi - lo;
  576. -     PyInt    extra = 0;    /* lines added to text, can be negative */
  577. -     char    **array;
  578. -     buf_T    *savebuf;
  579. - 
  580. -     if (new_len == 0)    /* avoid allocating zero bytes */
  581. -         array = NULL;
  582. -     else
  583. -     {
  584. -         array = (char **)alloc((unsigned)(new_len * sizeof(char *)));
  585. -         if (array == NULL)
  586. -         {
  587. -         PyErr_NoMemory();
  588. -         return FAIL;
  589. -         }
  590. -     }
  591. - 
  592. -     for (i = 0; i < new_len; ++i)
  593. -     {
  594. -         PyObject *line = PyList_GetItem(list, i);
  595. - 
  596. -         array[i] = StringToLine(line);
  597. -         if (array[i] == NULL)
  598. -         {
  599. -         while (i)
  600. -             vim_free(array[--i]);
  601. -         vim_free(array);
  602. -         return FAIL;
  603. -         }
  604. -     }
  605. - 
  606. -     savebuf = curbuf;
  607. - 
  608. -     PyErr_Clear();
  609. -     curbuf = buf;
  610. - 
  611. -     if (u_save((linenr_T)(lo-1), (linenr_T)hi) == FAIL)
  612. -         PyErr_SetVim(_("cannot save undo information"));
  613. - 
  614. -     /* If the size of the range is reducing (ie, new_len < old_len) we
  615. -      * need to delete some old_len. We do this at the start, by
  616. -      * repeatedly deleting line "lo".
  617. -      */
  618. -     if (!PyErr_Occurred())
  619. -     {
  620. -         for (i = 0; i < old_len - new_len; ++i)
  621. -         if (ml_delete((linenr_T)lo, FALSE) == FAIL)
  622. -         {
  623. -             PyErr_SetVim(_("cannot delete line"));
  624. -             break;
  625. -         }
  626. -         extra -= i;
  627. -     }
  628. - 
  629. -     /* For as long as possible, replace the existing old_len with the
  630. -      * new old_len. This is a more efficient operation, as it requires
  631. -      * less memory allocation and freeing.
  632. -      */
  633. -     if (!PyErr_Occurred())
  634. -     {
  635. -         for (i = 0; i < old_len && i < new_len; ++i)
  636. -         if (ml_replace((linenr_T)(lo+i), (char_u *)array[i], FALSE)
  637. -                                       == FAIL)
  638. -         {
  639. -             PyErr_SetVim(_("cannot replace line"));
  640. -             break;
  641. -         }
  642. -     }
  643. -     else
  644. -         i = 0;
  645. - 
  646. -     /* Now we may need to insert the remaining new old_len. If we do, we
  647. -      * must free the strings as we finish with them (we can't pass the
  648. -      * responsibility to vim in this case).
  649. -      */
  650. -     if (!PyErr_Occurred())
  651. -     {
  652. -         while (i < new_len)
  653. -         {
  654. -         if (ml_append((linenr_T)(lo + i - 1),
  655. -                     (char_u *)array[i], 0, FALSE) == FAIL)
  656. -         {
  657. -             PyErr_SetVim(_("cannot insert line"));
  658. -             break;
  659. -         }
  660. -         vim_free(array[i]);
  661. -         ++i;
  662. -         ++extra;
  663. -         }
  664. -     }
  665. - 
  666. -     /* Free any left-over old_len, as a result of an error */
  667. -     while (i < new_len)
  668. -     {
  669. -         vim_free(array[i]);
  670. -         ++i;
  671. -     }
  672. - 
  673. -     /* Free the array of old_len. All of its contents have now
  674. -      * been dealt with (either freed, or the responsibility passed
  675. -      * to vim.
  676. -      */
  677. -     vim_free(array);
  678. - 
  679. -     /* Adjust marks. Invalidate any which lie in the
  680. -      * changed range, and move any in the remainder of the buffer.
  681. -      */
  682. -     mark_adjust((linenr_T)lo, (linenr_T)(hi - 1),
  683. -                           (long)MAXLNUM, (long)extra);
  684. -     changed_lines((linenr_T)lo, 0, (linenr_T)hi, (long)extra);
  685. - 
  686. -     if (buf == curwin->w_buffer)
  687. -         py_fix_cursor((linenr_T)lo, (linenr_T)hi, (linenr_T)extra);
  688. - 
  689. -     curbuf = savebuf;
  690. - 
  691. -     if (PyErr_Occurred() || VimErrorCheck())
  692. -         return FAIL;
  693. - 
  694. -     if (len_change)
  695. -         *len_change = new_len - old_len;
  696. - 
  697. -     return OK;
  698. -     }
  699. -     else
  700. -     {
  701. -     PyErr_BadArgument();
  702. -     return FAIL;
  703. -     }
  704. - }
  705. - 
  706.   /* Convert a Vim line into a Python string.
  707.    * All internal newlines are replaced by null characters.
  708.    *
  709. --- 1404,1409 ----
  710. *** ../mercurial/vim73/src/if_python3.c    2011-06-12 21:37:06.000000000 +0200
  711. --- src/if_python3.c    2011-06-19 00:10:42.000000000 +0200
  712. ***************
  713. *** 70,77 ****
  714.   
  715.   #define PyInt Py_ssize_t
  716.   #define PyString_Check(obj) PyUnicode_Check(obj)
  717. ! #define PyString_AsString(obj) _PyUnicode_AsString(obj)
  718. ! #define PyString_Size(obj) PyUnicode_GET_SIZE(obj)
  719.   #define PyString_FromString(repr) PyUnicode_FromString(repr)
  720.   
  721.   #if defined(DYNAMIC_PYTHON3) || defined(PROTO)
  722. --- 70,79 ----
  723.   
  724.   #define PyInt Py_ssize_t
  725.   #define PyString_Check(obj) PyUnicode_Check(obj)
  726. ! #define PyString_AsBytes(obj) PyUnicode_AsEncodedString(obj, (char *)p_enc, NULL);
  727. ! #define PyString_FreeBytes(obj) Py_XDECREF(bytes)
  728. ! #define PyString_AsString(obj) PyBytes_AsString(obj)
  729. ! #define PyString_Size(obj) PyBytes_GET_SIZE(bytes)
  730.   #define PyString_FromString(repr) PyUnicode_FromString(repr)
  731.   
  732.   #if defined(DYNAMIC_PYTHON3) || defined(PROTO)
  733. ***************
  734. *** 99,104 ****
  735. --- 101,107 ----
  736.   # define PyArg_Parse py3_PyArg_Parse
  737.   # undef PyArg_ParseTuple
  738.   # define PyArg_ParseTuple py3_PyArg_ParseTuple
  739. + # define PyMem_Free py3_PyMem_Free
  740.   # define PyDict_SetItemString py3_PyDict_SetItemString
  741.   # define PyErr_BadArgument py3_PyErr_BadArgument
  742.   # define PyErr_Clear py3_PyErr_Clear
  743. ***************
  744. *** 140,147 ****
  745. --- 143,155 ----
  746.   # define PyModule_AddObject py3_PyModule_AddObject
  747.   # define PyImport_AppendInittab py3_PyImport_AppendInittab
  748.   # define _PyUnicode_AsString py3__PyUnicode_AsString
  749. + # undef PyUnicode_AsEncodedString
  750. + # define PyUnicode_AsEncodedString py3_PyUnicode_AsEncodedString
  751. + # undef PyBytes_AsString
  752. + # define PyBytes_AsString py3_PyBytes_AsString
  753.   # define PyObject_GenericGetAttr py3_PyObject_GenericGetAttr
  754.   # define PySlice_Type (*py3_PySlice_Type)
  755. + # define PyErr_NewException py3_PyErr_NewException
  756.   # ifdef Py_DEBUG
  757.   #  define _Py_NegativeRefcount py3__Py_NegativeRefcount
  758.   #  define _Py_RefTotal (*py3__Py_RefTotal)
  759. ***************
  760. *** 157,164 ****
  761.   # define PyModule_Create2 py3_PyModule_Create2
  762.   # undef PyUnicode_FromString
  763.   # define PyUnicode_FromString py3_PyUnicode_FromString
  764. ! # undef PyUnicode_FromStringAndSize
  765. ! # define PyUnicode_FromStringAndSize py3_PyUnicode_FromStringAndSize
  766.   
  767.   # ifdef Py_DEBUG
  768.   #  undef PyObject_NEW
  769. --- 165,172 ----
  770.   # define PyModule_Create2 py3_PyModule_Create2
  771.   # undef PyUnicode_FromString
  772.   # define PyUnicode_FromString py3_PyUnicode_FromString
  773. ! # undef PyUnicode_Decode
  774. ! # define PyUnicode_Decode py3_PyUnicode_Decode
  775.   
  776.   # ifdef Py_DEBUG
  777.   #  undef PyObject_NEW
  778. ***************
  779. *** 199,205 ****
  780.   static int (*py3_PyType_Ready)(PyTypeObject *type);
  781.   static int (*py3_PyDict_SetItemString)(PyObject *dp, char *key, PyObject *item);
  782.   static PyObject* (*py3_PyUnicode_FromString)(const char *u);
  783. ! static PyObject* (*py3_PyUnicode_FromStringAndSize)(const char *u, Py_ssize_t size);
  784.   static long (*py3_PyLong_AsLong)(PyObject *);
  785.   static void (*py3_PyErr_SetNone)(PyObject *);
  786.   static void (*py3_PyEval_InitThreads)(void);
  787. --- 207,214 ----
  788.   static int (*py3_PyType_Ready)(PyTypeObject *type);
  789.   static int (*py3_PyDict_SetItemString)(PyObject *dp, char *key, PyObject *item);
  790.   static PyObject* (*py3_PyUnicode_FromString)(const char *u);
  791. ! static PyObject* (*py3_PyUnicode_Decode)(const char *u, Py_ssize_t size,
  792. !     const char *encoding, const char *errors);
  793.   static long (*py3_PyLong_AsLong)(PyObject *);
  794.   static void (*py3_PyErr_SetNone)(PyObject *);
  795.   static void (*py3_PyEval_InitThreads)(void);
  796. ***************
  797. *** 207,212 ****
  798. --- 216,222 ----
  799.   static PyThreadState*(*py3_PyEval_SaveThread)(void);
  800.   static int (*py3_PyArg_Parse)(PyObject *, char *, ...);
  801.   static int (*py3_PyArg_ParseTuple)(PyObject *, char *, ...);
  802. + static int (*py3_PyMem_Free)(void *);
  803.   static int (*py3_Py_IsInitialized)(void);
  804.   static void (*py3_PyErr_Clear)(void);
  805.   static PyObject*(*py3__PyObject_Init)(PyObject *, PyTypeObject *);
  806. ***************
  807. *** 214,224 ****
  808. --- 224,237 ----
  809.   static int (*py3_PyModule_AddObject)(PyObject *m, const char *name, PyObject *o);
  810.   static int (*py3_PyImport_AppendInittab)(const char *name, PyObject* (*initfunc)(void));
  811.   static char* (*py3__PyUnicode_AsString)(PyObject *unicode);
  812. + static PyObject* (*py3_PyUnicode_AsEncodedString)(PyObject *unicode, const char* encoding, const char* errors);
  813. + static char* (*py3_PyBytes_AsString)(PyObject *bytes);
  814.   static PyObject* (*py3_PyObject_GenericGetAttr)(PyObject *obj, PyObject *name);
  815.   static PyObject* (*py3_PyModule_Create2)(struct PyModuleDef* module, int module_api_version);
  816.   static PyObject* (*py3_PyType_GenericAlloc)(PyTypeObject *type, Py_ssize_t nitems);
  817.   static PyObject* (*py3_PyType_GenericNew)(PyTypeObject *type, PyObject *args, PyObject *kwds);
  818.   static PyTypeObject* py3_PySlice_Type;
  819. + static PyObject* (*py3_PyErr_NewException)(char *name, PyObject *base, PyObject *dict);
  820.   # ifdef Py_DEBUG
  821.       static void (*py3__Py_NegativeRefcount)(const char *fname, int lineno, PyObject *op);
  822.       static Py_ssize_t* py3__Py_RefTotal;
  823. ***************
  824. *** 259,264 ****
  825. --- 272,278 ----
  826.       {"Py_SetPythonHome", (PYTHON_PROC*)&py3_Py_SetPythonHome},
  827.       {"Py_Initialize", (PYTHON_PROC*)&py3_Py_Initialize},
  828.       {"PyArg_ParseTuple", (PYTHON_PROC*)&py3_PyArg_ParseTuple},
  829. +     {"PyMem_Free", (PYTHON_PROC*)&py3_PyMem_Free},
  830.       {"PyList_New", (PYTHON_PROC*)&py3_PyList_New},
  831.       {"PyGILState_Ensure", (PYTHON_PROC*)&py3_PyGILState_Ensure},
  832.       {"PyGILState_Release", (PYTHON_PROC*)&py3_PyGILState_Release},
  833. ***************
  834. *** 289,295 ****
  835.       {"PyEval_RestoreThread", (PYTHON_PROC*)&py3_PyEval_RestoreThread},
  836.       {"PyEval_SaveThread", (PYTHON_PROC*)&py3_PyEval_SaveThread},
  837.       {"PyArg_Parse", (PYTHON_PROC*)&py3_PyArg_Parse},
  838. -     {"PyArg_ParseTuple", (PYTHON_PROC*)&py3_PyArg_ParseTuple},
  839.       {"Py_IsInitialized", (PYTHON_PROC*)&py3_Py_IsInitialized},
  840.       {"_Py_NoneStruct", (PYTHON_PROC*)&py3__Py_NoneStruct},
  841.       {"PyErr_Clear", (PYTHON_PROC*)&py3_PyErr_Clear},
  842. --- 303,308 ----
  843. ***************
  844. *** 297,307 ****
  845. --- 310,322 ----
  846.       {"PyModule_AddObject", (PYTHON_PROC*)&py3_PyModule_AddObject},
  847.       {"PyImport_AppendInittab", (PYTHON_PROC*)&py3_PyImport_AppendInittab},
  848.       {"_PyUnicode_AsString", (PYTHON_PROC*)&py3__PyUnicode_AsString},
  849. +     {"PyBytes_AsString", (PYTHON_PROC*)&py3_PyBytes_AsString},
  850.       {"PyObject_GenericGetAttr", (PYTHON_PROC*)&py3_PyObject_GenericGetAttr},
  851.       {"PyModule_Create2", (PYTHON_PROC*)&py3_PyModule_Create2},
  852.       {"PyType_GenericAlloc", (PYTHON_PROC*)&py3_PyType_GenericAlloc},
  853.       {"PyType_GenericNew", (PYTHON_PROC*)&py3_PyType_GenericNew},
  854.       {"PySlice_Type", (PYTHON_PROC*)&py3_PySlice_Type},
  855. +     {"PyErr_NewException", (PYTHON_PROC*)&py3_PyErr_NewException},
  856.   # ifdef Py_DEBUG
  857.       {"_Py_NegativeRefcount", (PYTHON_PROC*)&py3__Py_NegativeRefcount},
  858.       {"_Py_RefTotal", (PYTHON_PROC*)&py3__Py_RefTotal},
  859. ***************
  860. *** 337,343 ****
  861.   py3_runtime_link_init(char *libname, int verbose)
  862.   {
  863.       int i;
  864. !     void *ucs_from_string, *ucs_from_string_and_size;
  865.   
  866.   # if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON)
  867.       /* Can't have Python and Python3 loaded at the same time.
  868. --- 352,358 ----
  869.   py3_runtime_link_init(char *libname, int verbose)
  870.   {
  871.       int i;
  872. !     void *ucs_from_string, *ucs_decode, *ucs_as_encoded_string;
  873.   
  874.   # if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON)
  875.       /* Can't have Python and Python3 loaded at the same time.
  876. ***************
  877. *** 377,395 ****
  878.       /* Load unicode functions separately as only the ucs2 or the ucs4 functions
  879.        * will be present in the library. */
  880.       ucs_from_string = symbol_from_dll(hinstPy3, "PyUnicodeUCS2_FromString");
  881. !     ucs_from_string_and_size = symbol_from_dll(hinstPy3,
  882. !         "PyUnicodeUCS2_FromStringAndSize");
  883. !     if (!ucs_from_string || !ucs_from_string_and_size)
  884.       {
  885.       ucs_from_string = symbol_from_dll(hinstPy3,
  886.           "PyUnicodeUCS4_FromString");
  887. !     ucs_from_string_and_size = symbol_from_dll(hinstPy3,
  888. !         "PyUnicodeUCS4_FromStringAndSize");
  889.       }
  890. !     if (ucs_from_string && ucs_from_string_and_size)
  891.       {
  892.       py3_PyUnicode_FromString = ucs_from_string;
  893. !     py3_PyUnicode_FromStringAndSize = ucs_from_string_and_size;
  894.       }
  895.       else
  896.       {
  897. --- 392,415 ----
  898.       /* Load unicode functions separately as only the ucs2 or the ucs4 functions
  899.        * will be present in the library. */
  900.       ucs_from_string = symbol_from_dll(hinstPy3, "PyUnicodeUCS2_FromString");
  901. !     ucs_decode = symbol_from_dll(hinstPy3,
  902. !         "PyUnicodeUCS2_Decode");
  903. !     ucs_as_encoded_string = symbol_from_dll(hinstPy3,
  904. !         "PyUnicodeUCS2_AsEncodedString");
  905. !     if (!ucs_from_string || !ucs_decode || !ucs_as_encoded_string)
  906.       {
  907.       ucs_from_string = symbol_from_dll(hinstPy3,
  908.           "PyUnicodeUCS4_FromString");
  909. !     ucs_decode = symbol_from_dll(hinstPy3,
  910. !         "PyUnicodeUCS4_Decode");
  911. !     ucs_as_encoded_string = symbol_from_dll(hinstPy3,
  912. !         "PyUnicodeUCS4_AsEncodedString");
  913.       }
  914. !     if (ucs_from_string && ucs_decode && ucs_as_encoded_string)
  915.       {
  916.       py3_PyUnicode_FromString = ucs_from_string;
  917. !     py3_PyUnicode_Decode = ucs_decode;
  918. !     py3_PyUnicode_AsEncodedString = ucs_as_encoded_string;
  919.       }
  920.       else
  921.       {
  922. ***************
  923. *** 567,574 ****
  924.       /* Remove the element from sys.path that was added because of our
  925.        * argv[0] value in Py3Init_vim().  Previously we used an empty
  926.        * string, but dependinding on the OS we then get an empty entry or
  927. !      * the current directory in sys.path. */
  928. !     PyRun_SimpleString("import sys; sys.path = list(filter(lambda x: x != '/must>not&exist', sys.path))");
  929.   
  930.       // lock is created and acquired in PyEval_InitThreads() and thread
  931.       // state is created in Py_Initialize()
  932. --- 587,597 ----
  933.       /* Remove the element from sys.path that was added because of our
  934.        * argv[0] value in Py3Init_vim().  Previously we used an empty
  935.        * string, but dependinding on the OS we then get an empty entry or
  936. !      * the current directory in sys.path.
  937. !      * Only after vim has been imported, the element does exist in
  938. !      * sys.path.
  939. !      */
  940. !     PyRun_SimpleString("import vim; import sys; sys.path = list(filter(lambda x: not x.endswith('must>not&exist'), sys.path))");
  941.   
  942.       // lock is created and acquired in PyEval_InitThreads() and thread
  943.       // state is created in Py_Initialize()
  944. ***************
  945. *** 605,610 ****
  946. --- 628,635 ----
  947.   #if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
  948.       char        *saved_locale;
  949.   #endif
  950. +     PyObject        *cmdstr;
  951. +     PyObject        *cmdbytes;
  952.   
  953.   #if defined(MACOS) && !defined(MACOS_X_UNIX)
  954.       GetPort(&oldPort);
  955. ***************
  956. *** 634,640 ****
  957.   
  958.       pygilstate = PyGILState_Ensure();
  959.   
  960. !     PyRun_SimpleString((char *)(cmd));
  961.   
  962.       PyGILState_Release(pygilstate);
  963.   
  964. --- 659,671 ----
  965.   
  966.       pygilstate = PyGILState_Ensure();
  967.   
  968. !     /* PyRun_SimpleString expects a UTF-8 string. Wrong encoding may cause
  969. !      * SyntaxError (unicode error). */
  970. !     cmdstr = PyUnicode_Decode(cmd, strlen(cmd), (char *)p_enc, NULL);
  971. !     cmdbytes = PyUnicode_AsEncodedString(cmdstr, "utf-8", NULL);
  972. !     Py_XDECREF(cmdstr);
  973. !     PyRun_SimpleString(PyBytes_AsString(cmdbytes));
  974. !     Py_XDECREF(cmdbytes);
  975.   
  976.       PyGILState_Release(pygilstate);
  977.   
  978. ***************
  979. *** 693,699 ****
  980.        * different options under Windows, meaning that stdio pointers aren't
  981.        * compatible between the two. Yuk.
  982.        *
  983. !      * construct: exec(compile(open('a_filename').read(), 'a_filename', 'exec'))
  984.        *
  985.        * We need to escape any backslashes or single quotes in the file name, so that
  986.        * Python won't mangle the file name.
  987. --- 724,733 ----
  988.        * different options under Windows, meaning that stdio pointers aren't
  989.        * compatible between the two. Yuk.
  990.        *
  991. !      * construct: exec(compile(open('a_filename', 'rb').read(), 'a_filename', 'exec'))
  992. !      *
  993. !      * Using bytes so that Python can detect the source encoding as it normally
  994. !      * does. The doc does not say "compile" accept bytes, though.
  995.        *
  996.        * We need to escape any backslashes or single quotes in the file name, so that
  997.        * Python won't mangle the file name.
  998. ***************
  999. *** 716,723 ****
  1000.           return;
  1001.       if (i==0)
  1002.       {
  1003. !         strcpy(p,"').read(),'");
  1004. !         p += 11;
  1005.       }
  1006.       else
  1007.       {
  1008. --- 750,757 ----
  1009.           return;
  1010.       if (i==0)
  1011.       {
  1012. !         strcpy(p,"','rb').read(),'");
  1013. !         p += 16;
  1014.       }
  1015.       else
  1016.       {
  1017. ***************
  1018. *** 812,819 ****
  1019.   
  1020.   static Py_ssize_t BufferLength(PyObject *);
  1021.   static PyObject *BufferItem(PyObject *, Py_ssize_t);
  1022. - static Py_ssize_t BufferAsItem(PyObject *, Py_ssize_t, PyObject *);
  1023.   static PyObject* BufferSubscript(PyObject *self, PyObject* idx);
  1024.   
  1025.   
  1026.   /* Line range type - Implementation functions
  1027. --- 846,853 ----
  1028.   
  1029.   static Py_ssize_t BufferLength(PyObject *);
  1030.   static PyObject *BufferItem(PyObject *, Py_ssize_t);
  1031.   static PyObject* BufferSubscript(PyObject *self, PyObject* idx);
  1032. + static Py_ssize_t BufferAsSubscript(PyObject *self, PyObject* idx, PyObject* val);
  1033.   
  1034.   
  1035.   /* Line range type - Implementation functions
  1036. ***************
  1037. *** 835,841 ****
  1038.       (ssizeargfunc)    0,            /* sq_repeat,    x*n      */
  1039.       (ssizeargfunc)    BufferItem,        /* sq_item,      x[i]     */
  1040.       0,                        /* was_sq_slice,     x[i:j]   */
  1041. !     (ssizeobjargproc)    BufferAsItem,        /* sq_ass_item,  x[i]=v   */
  1042.       0,                        /* sq_ass_slice, x[i:j]=v */
  1043.       0,                        /* sq_contains */
  1044.       0,                        /* sq_inplace_concat */
  1045. --- 869,875 ----
  1046.       (ssizeargfunc)    0,            /* sq_repeat,    x*n      */
  1047.       (ssizeargfunc)    BufferItem,        /* sq_item,      x[i]     */
  1048.       0,                        /* was_sq_slice,     x[i:j]   */
  1049. !     0,                        /* sq_ass_item,  x[i]=v   */
  1050.       0,                        /* sq_ass_slice, x[i:j]=v */
  1051.       0,                        /* sq_contains */
  1052.       0,                        /* sq_inplace_concat */
  1053. ***************
  1054. *** 845,851 ****
  1055.   PyMappingMethods BufferAsMapping = {
  1056.       /* mp_length    */ (lenfunc)BufferLength,
  1057.       /* mp_subscript     */ (binaryfunc)BufferSubscript,
  1058. !     /* mp_ass_subscript */ (objobjargproc)0,
  1059.   };
  1060.   
  1061.   
  1062. --- 879,885 ----
  1063.   PyMappingMethods BufferAsMapping = {
  1064.       /* mp_length    */ (lenfunc)BufferLength,
  1065.       /* mp_subscript     */ (binaryfunc)BufferSubscript,
  1066. !     /* mp_ass_subscript */ (objobjargproc)BufferAsSubscript,
  1067.   };
  1068.   
  1069.   
  1070. ***************
  1071. *** 897,902 ****
  1072. --- 931,938 ----
  1073.   
  1074.       if (this->buf && this->buf != INVALID_BUFFER_VALUE)
  1075.       this->buf->b_python3_ref = NULL;
  1076. + 
  1077. +     Py_TYPE(self)->tp_free((PyObject*)self);
  1078.   }
  1079.   
  1080.       static PyObject *
  1081. ***************
  1082. *** 975,989 ****
  1083.              (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count);
  1084.   }
  1085.   
  1086. -     static Py_ssize_t
  1087. - BufferAsItem(PyObject *self, Py_ssize_t n, PyObject *val)
  1088. - {
  1089. -     return RBAsItem((BufferObject *)(self), n, val, 1,
  1090. -         (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
  1091. -         NULL);
  1092. - }
  1093. - 
  1094. - 
  1095.       static PyObject *
  1096.   BufferSubscript(PyObject *self, PyObject* idx)
  1097.   {
  1098. --- 1011,1016 ----
  1099. ***************
  1100. *** 999,1011 ****
  1101.             &step, &slicelen) < 0) {
  1102.           return NULL;
  1103.       }
  1104. !     return BufferSlice(self,start,stop+1);
  1105.       } else {
  1106.       PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
  1107.       return NULL;
  1108.       }
  1109.   }
  1110.   
  1111.   static PySequenceMethods RangeAsSeq = {
  1112.       (lenfunc)        RangeLength,     /* sq_length,      len(x)   */
  1113.       (binaryfunc)    0,         /* RangeConcat, sq_concat,  x+y   */
  1114. --- 1026,1064 ----
  1115.             &step, &slicelen) < 0) {
  1116.           return NULL;
  1117.       }
  1118. !     return BufferSlice(self,start,stop);
  1119.       } else {
  1120.       PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
  1121.       return NULL;
  1122.       }
  1123.   }
  1124.   
  1125. +     static Py_ssize_t
  1126. + BufferAsSubscript(PyObject *self, PyObject* idx, PyObject* val)
  1127. + {
  1128. +     if (PyLong_Check(idx)) {
  1129. +     long n = PyLong_AsLong(idx);
  1130. +     return RBAsItem((BufferObject *)(self), n, val, 1,
  1131. +             (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
  1132. +             NULL);
  1133. +     } else if (PySlice_Check(idx)) {
  1134. +     Py_ssize_t start, stop, step, slicelen;
  1135. + 
  1136. +     if (PySlice_GetIndicesEx((PySliceObject *)idx,
  1137. +           (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count+1,
  1138. +           &start, &stop,
  1139. +           &step, &slicelen) < 0) {
  1140. +         return -1;
  1141. +     }
  1142. +     return RBAsSlice((BufferObject *)(self), start, stop, val, 1,
  1143. +               (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count,
  1144. +               NULL);
  1145. +     } else {
  1146. +     PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
  1147. +     return -1;
  1148. +     }
  1149. + }
  1150. + 
  1151.   static PySequenceMethods RangeAsSeq = {
  1152.       (lenfunc)        RangeLength,     /* sq_length,      len(x)   */
  1153.       (binaryfunc)    0,         /* RangeConcat, sq_concat,  x+y   */
  1154. ***************
  1155. *** 1032,1037 ****
  1156. --- 1085,1091 ----
  1157.   RangeDestructor(PyObject *self)
  1158.   {
  1159.       Py_DECREF(((RangeObject *)(self))->buf);
  1160. +     Py_TYPE(self)->tp_free((PyObject*)self);
  1161.   }
  1162.   
  1163.       static PyObject *
  1164. ***************
  1165. *** 1159,1164 ****
  1166. --- 1213,1220 ----
  1167.   
  1168.       if (this->win && this->win != INVALID_WINDOW_VALUE)
  1169.       this->win->w_python3_ref = NULL;
  1170. + 
  1171. +     Py_TYPE(self)->tp_free((PyObject*)self);
  1172.   }
  1173.   
  1174.       static PyObject *
  1175. ***************
  1176. *** 1350,1357 ****
  1177.       PySys_SetArgv(1, argv);
  1178.   
  1179.       mod = PyModule_Create(&vimmodule);
  1180.   
  1181. !     VimError = Py_BuildValue("s", "vim.error");
  1182.   
  1183.       PyModule_AddObject(mod, "error", VimError);
  1184.       Py_INCREF((PyObject *)(void *)&TheBufferList);
  1185. --- 1406,1416 ----
  1186.       PySys_SetArgv(1, argv);
  1187.   
  1188.       mod = PyModule_Create(&vimmodule);
  1189. +     if (mod == NULL)
  1190. +     return NULL;
  1191.   
  1192. !     VimError = PyErr_NewException("vim.error", NULL, NULL);
  1193. !     Py_INCREF(VimError);
  1194.   
  1195.       PyModule_AddObject(mod, "error", VimError);
  1196.       Py_INCREF((PyObject *)(void *)&TheBufferList);
  1197. ***************
  1198. *** 1404,1410 ****
  1199.       }
  1200.       *p = '\0';
  1201.   
  1202. !     result = PyUnicode_FromStringAndSize(tmp, len);
  1203.   
  1204.       vim_free(tmp);
  1205.       return result;
  1206. --- 1463,1469 ----
  1207.       }
  1208.       *p = '\0';
  1209.   
  1210. !     result = PyUnicode_Decode(tmp, len, (char *)p_enc, NULL);
  1211.   
  1212.       vim_free(tmp);
  1213.       return result;
  1214. *** ../vim-7.3.219/src/version.c    2011-06-13 02:03:55.000000000 +0200
  1215. --- src/version.c    2011-06-19 00:25:38.000000000 +0200
  1216. ***************
  1217. *** 711,712 ****
  1218. --- 711,714 ----
  1219.   {   /* Add new patch number below this line */
  1220. + /**/
  1221. +     220,
  1222.   /**/
  1223.  
  1224. -- 
  1225. I'm in shape.  Round IS a shape.
  1226.  
  1227.  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
  1228. ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
  1229. \\\  an exciting new programming language -- http://www.Zimbu.org        ///
  1230.  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///
  1231.