7.1.307

   1 To: vim-dev@vim.org
   2 Subject: Patch 7.1.307
   3 Fcc: outbox
   4 From: Bram Moolenaar <Bram@moolenaar.net>
   5 Mime-Version: 1.0
   6 Content-Type: text/plain; charset=ISO-8859-1
   7 Content-Transfer-Encoding: 8bit
   8 ------------
   9
  10 Patch 7.1.307
  11 Problem:    Many warnings when compiling with Python 2.5.
  12 Solution:   Use ssize_t instead of int for some types. (James Vega)
  13 Files:      src/if_python.c
  14
  15
  16 *** ../vim-7.1.306/src/if_python.c      Thu Mar  8 10:20:28 2007
  17 --- src/if_python.c     Wed May  7 16:55:44 2008
  18 ***************
  19 *** 38,43 ****
  20 --- 38,45 ----
  21   # undef HAVE_STDARG_H /* Python's config.h defines it as well. */
  22   #endif
  23
  24 + #define PY_SSIZE_T_CLEAN
  25 +
  26   #include <Python.h>
  27   #if defined(MACOS) && !defined(MACOS_X_UNIX)
  28   # include "macglue.h"
  29 ***************
  30 *** 55,60 ****
  31 --- 57,78 ----
  32   # define PySequenceMethods int
  33   #endif
  34
  35 + #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02050000
  36 + # define PyInt Py_ssize_t
  37 + # define PyInquiry lenfunc
  38 + # define PyIntArgFunc ssizeargfunc
  39 + # define PyIntIntArgFunc ssizessizeargfunc
  40 + # define PyIntObjArgProc ssizeobjargproc
  41 + # define PyIntIntObjArgProc ssizessizeobjargproc
  42 + #else
  43 + # define PyInt int
  44 + # define PyInquiry inquiry
  45 + # define PyIntArgFunc intargfunc
  46 + # define PyIntIntArgFunc intintargfunc
  47 + # define PyIntObjArgProc intobjargproc
  48 + # define PyIntIntObjArgProc intintobjargproc
  49 + #endif
  50 +
  51   /* Parser flags */
  52   #define single_input  256
  53   #define file_input    257
  54 ***************
  55 *** 150,160 ****
  56   static long(*dll_PyInt_AsLong)(PyObject *);
  57   static PyObject*(*dll_PyInt_FromLong)(long);
  58   static PyTypeObject* dll_PyInt_Type;
  59 ! static PyObject*(*dll_PyList_GetItem)(PyObject *, int);
  60   static PyObject*(*dll_PyList_Append)(PyObject *, PyObject *);
  61 ! static PyObject*(*dll_PyList_New)(int size);
  62 ! static int(*dll_PyList_SetItem)(PyObject *, int, PyObject *);
  63 ! static int(*dll_PyList_Size)(PyObject *);
  64   static PyTypeObject* dll_PyList_Type;
  65   static PyObject*(*dll_PyImport_ImportModule)(const char *);
  66   static PyObject*(*dll_PyDict_New)(void);
  67 --- 168,178 ----
  68   static long(*dll_PyInt_AsLong)(PyObject *);
  69   static PyObject*(*dll_PyInt_FromLong)(long);
  70   static PyTypeObject* dll_PyInt_Type;
  71 ! static PyObject*(*dll_PyList_GetItem)(PyObject *, PyInt);
  72   static PyObject*(*dll_PyList_Append)(PyObject *, PyObject *);
  73 ! static PyObject*(*dll_PyList_New)(PyInt size);
  74 ! static int(*dll_PyList_SetItem)(PyObject *, PyInt, PyObject *);
  75 ! static PyInt(*dll_PyList_Size)(PyObject *);
  76   static PyTypeObject* dll_PyList_Type;
  77   static PyObject*(*dll_PyImport_ImportModule)(const char *);
  78   static PyObject*(*dll_PyDict_New)(void);
  79 ***************
  80 *** 163,170 ****
  81   static int(*dll_PyRun_SimpleString)(char *);
  82   static char*(*dll_PyString_AsString)(PyObject *);
  83   static PyObject*(*dll_PyString_FromString)(const char *);
  84 ! static PyObject*(*dll_PyString_FromStringAndSize)(const char *, int);
  85 ! static int(*dll_PyString_Size)(PyObject *);
  86   static PyTypeObject* dll_PyString_Type;
  87   static int(*dll_PySys_SetObject)(char *, PyObject *);
  88   static int(*dll_PySys_SetArgv)(int, char **);
  89 --- 181,188 ----
  90   static int(*dll_PyRun_SimpleString)(char *);
  91   static char*(*dll_PyString_AsString)(PyObject *);
  92   static PyObject*(*dll_PyString_FromString)(const char *);
  93 ! static PyObject*(*dll_PyString_FromStringAndSize)(const char *, PyInt);
  94 ! static PyInt(*dll_PyString_Size)(PyObject *);
  95   static PyTypeObject* dll_PyString_Type;
  96   static int(*dll_PySys_SetObject)(char *, PyObject *);
  97   static int(*dll_PySys_SetArgv)(int, char **);
  98 ***************
  99 *** 367,376 ****
 100    * ----------------------------------------------
 101    */
 102   static PyObject *GetBufferLine(buf_T *, int);
 103 ! static PyObject *GetBufferLineList(buf_T *, int, int);
 104
 105   static int SetBufferLine(buf_T *, int, PyObject *, int *);
 106 ! static int SetBufferLineList(buf_T *, int, int, PyObject *, int *);
 107   static int InsertBufferLines(buf_T *, int, PyObject *, int *);
 108
 109   static PyObject *LineToString(const char *);
 110 --- 385,394 ----
 111    * ----------------------------------------------
 112    */
 113   static PyObject *GetBufferLine(buf_T *, int);
 114 ! static PyObject *GetBufferLineList(buf_T *, PyInt, PyInt);
 115
 116   static int SetBufferLine(buf_T *, int, PyObject *, int *);
 117 ! static int SetBufferLineList(buf_T *, PyInt, PyInt, PyObject *, int *);
 118   static int InsertBufferLines(buf_T *, int, PyObject *, int *);
 119
 120   static PyObject *LineToString(const char *);
 121 ***************
 122 *** 773,780 ****
 123       static PyObject *
 124   OutputWritelines(PyObject *self, PyObject *args)
 125   {
 126 !     int n;
 127 !     int i;
 128       PyObject *list;
 129       int error = ((OutputObject *)(self))->error;
 130
 131 --- 791,798 ----
 132       static PyObject *
 133   OutputWritelines(PyObject *self, PyObject *args)
 134   {
 135 !     PyInt n;
 136 !     PyInt i;
 137       PyObject *list;
 138       int error = ((OutputObject *)(self))->error;
 139
 140 ***************
 141 *** 986,996 ****
 142   static PyObject *BufferGetattr(PyObject *, char *);
 143   static PyObject *BufferRepr(PyObject *);
 144
 145 ! static int BufferLength(PyObject *);
 146 ! static PyObject *BufferItem(PyObject *, int);
 147 ! static PyObject *BufferSlice(PyObject *, int, int);
 148 ! static int BufferAssItem(PyObject *, int, PyObject *);
 149 ! static int BufferAssSlice(PyObject *, int, int, PyObject *);
 150
 151   static PyObject *BufferAppend(PyObject *, PyObject *);
 152   static PyObject *BufferMark(PyObject *, PyObject *);
 153 --- 1004,1014 ----
 154   static PyObject *BufferGetattr(PyObject *, char *);
 155   static PyObject *BufferRepr(PyObject *);
 156
 157 ! static PyInt BufferLength(PyObject *);
 158 ! static PyObject *BufferItem(PyObject *, PyInt);
 159 ! static PyObject *BufferSlice(PyObject *, PyInt, PyInt);
 160 ! static PyInt BufferAssItem(PyObject *, PyInt, PyObject *);
 161 ! static PyInt BufferAssSlice(PyObject *, PyInt, PyInt, PyObject *);
 162
 163   static PyObject *BufferAppend(PyObject *, PyObject *);
 164   static PyObject *BufferMark(PyObject *, PyObject *);
 165 ***************
 166 *** 1017,1027 ****
 167   static PyObject *RangeGetattr(PyObject *, char *);
 168   static PyObject *RangeRepr(PyObject *);
 169
 170 ! static int RangeLength(PyObject *);
 171 ! static PyObject *RangeItem(PyObject *, int);
 172 ! static PyObject *RangeSlice(PyObject *, int, int);
 173 ! static int RangeAssItem(PyObject *, int, PyObject *);
 174 ! static int RangeAssSlice(PyObject *, int, int, PyObject *);
 175
 176   static PyObject *RangeAppend(PyObject *, PyObject *);
 177
 178 --- 1035,1045 ----
 179   static PyObject *RangeGetattr(PyObject *, char *);
 180   static PyObject *RangeRepr(PyObject *);
 181
 182 ! static PyInt RangeLength(PyObject *);
 183 ! static PyObject *RangeItem(PyObject *, PyInt);
 184 ! static PyObject *RangeSlice(PyObject *, PyInt, PyInt);
 185 ! static PyInt RangeAssItem(PyObject *, PyInt, PyObject *);
 186 ! static PyInt RangeAssSlice(PyObject *, PyInt, PyInt, PyObject *);
 187
 188   static PyObject *RangeAppend(PyObject *, PyObject *);
 189
 190 ***************
 191 *** 1029,1043 ****
 192    * -------------------------------------------
 193    */
 194
 195 ! static int WinListLength(PyObject *);
 196 ! static PyObject *WinListItem(PyObject *, int);
 197
 198   /* Buffer list type - Implementation functions
 199    * -------------------------------------------
 200    */
 201
 202 ! static int BufListLength(PyObject *);
 203 ! static PyObject *BufListItem(PyObject *, int);
 204
 205   /* Current objects type - Implementation functions
 206    * -----------------------------------------------
 207 --- 1047,1061 ----
 208    * -------------------------------------------
 209    */
 210
 211 ! static PyInt WinListLength(PyObject *);
 212 ! static PyObject *WinListItem(PyObject *, PyInt);
 213
 214   /* Buffer list type - Implementation functions
 215    * -------------------------------------------
 216    */
 217
 218 ! static PyInt BufListLength(PyObject *);
 219 ! static PyObject *BufListItem(PyObject *, PyInt);
 220
 221   /* Current objects type - Implementation functions
 222    * -----------------------------------------------
 223 ***************
 224 *** 1130,1135 ****
 225 --- 1148,1163 ----
 226         result = Py_BuildValue("s", buf);
 227         PyDict_SetItemString(lookupDict, ptrBuf, result);
 228       }
 229 + #ifdef FEAT_FLOAT
 230 +     else if (our_tv->v_type == VAR_FLOAT)
 231 +     {
 232 +       char buf[NUMBUFLEN];
 233 +
 234 +       sprintf(buf, "%f", our_tv->vval.v_float);
 235 +       result = Py_BuildValue("s", buf);
 236 +       PyDict_SetItemString(lookupDict, ptrBuf, result);
 237 +     }
 238 + #endif
 239       else if (our_tv->v_type == VAR_LIST)
 240       {
 241         list_T          *list = our_tv->vval.v_list;
 242 ***************
 243 *** 1245,1251 ****
 244   }
 245
 246       static PyObject *
 247 ! RBItem(BufferObject *self, int n, int start, int end)
 248   {
 249       if (CheckBuffer(self))
 250         return NULL;
 251 --- 1273,1279 ----
 252   }
 253
 254       static PyObject *
 255 ! RBItem(BufferObject *self, PyInt n, int start, int end)
 256   {
 257       if (CheckBuffer(self))
 258         return NULL;
 259 ***************
 260 *** 1260,1268 ****
 261   }
 262
 263       static PyObject *
 264 ! RBSlice(BufferObject *self, int lo, int hi, int start, int end)
 265   {
 266 !     int size;
 267
 268       if (CheckBuffer(self))
 269         return NULL;
 270 --- 1288,1296 ----
 271   }
 272
 273       static PyObject *
 274 ! RBSlice(BufferObject *self, PyInt lo, PyInt hi, int start, int end)
 275   {
 276 !     PyInt size;
 277
 278       if (CheckBuffer(self))
 279         return NULL;
 280 ***************
 281 *** 1283,1290 ****
 282       return GetBufferLineList(self->buf, lo+start, hi+start);
 283   }
 284
 285 !     static int
 286 ! RBAssItem(BufferObject *self, int n, PyObject *val, int start, int end, int *new_end)
 287   {
 288       int len_change;
 289
 290 --- 1311,1318 ----
 291       return GetBufferLineList(self->buf, lo+start, hi+start);
 292   }
 293
 294 !     static PyInt
 295 ! RBAssItem(BufferObject *self, PyInt n, PyObject *val, int start, int end, int *new_end)
 296   {
 297       int len_change;
 298
 299 ***************
 300 *** 1306,1313 ****
 301       return 0;
 302   }
 303
 304 !     static int
 305 ! RBAssSlice(BufferObject *self, int lo, int hi, PyObject *val, int start, int end, int *new_end)
 306   {
 307       int size;
 308       int len_change;
 309 --- 1334,1341 ----
 310       return 0;
 311   }
 312
 313 !     static PyInt
 314 ! RBAssSlice(BufferObject *self, PyInt lo, PyInt hi, PyObject *val, int start, int end, int *new_end)
 315   {
 316       int size;
 317       int len_change;
 318 ***************
 319 *** 1384,1396 ****
 320   };
 321
 322   static PySequenceMethods BufferAsSeq = {
 323 !     (inquiry)         BufferLength,       /* sq_length,    len(x)   */
 324       (binaryfunc)      0, /* BufferConcat, */       /* sq_concat,    x+y      */
 325 !     (intargfunc)      0, /* BufferRepeat, */       /* sq_repeat,    x*n      */
 326 !     (intargfunc)      BufferItem,         /* sq_item,      x[i]     */
 327 !     (intintargfunc)   BufferSlice,        /* sq_slice,     x[i:j]   */
 328 !     (intobjargproc)   BufferAssItem,      /* sq_ass_item,  x[i]=v   */
 329 !     (intintobjargproc)        BufferAssSlice,     /* sq_ass_slice, x[i:j]=v */
 330   };
 331
 332   static PyTypeObject BufferType = {
 333 --- 1412,1424 ----
 334   };
 335
 336   static PySequenceMethods BufferAsSeq = {
 337 !     (PyInquiry)               BufferLength,       /* sq_length,    len(x)   */
 338       (binaryfunc)      0, /* BufferConcat, */       /* sq_concat,    x+y      */
 339 !     (PyIntArgFunc)    0, /* BufferRepeat, */       /* sq_repeat,    x*n      */
 340 !     (PyIntArgFunc)    BufferItem,         /* sq_item,      x[i]     */
 341 !     (PyIntIntArgFunc) BufferSlice,        /* sq_slice,     x[i:j]   */
 342 !     (PyIntObjArgProc) BufferAssItem,      /* sq_ass_item,  x[i]=v   */
 343 !     (PyIntIntObjArgProc)      BufferAssSlice,     /* sq_ass_slice, x[i:j]=v */
 344   };
 345
 346   static PyTypeObject BufferType = {
 347 ***************
 348 *** 1516,1522 ****
 349
 350   /******************/
 351
 352 !     static int
 353   BufferLength(PyObject *self)
 354   {
 355       /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
 356 --- 1544,1550 ----
 357
 358   /******************/
 359
 360 !     static PyInt
 361   BufferLength(PyObject *self)
 362   {
 363       /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
 364 ***************
 365 *** 1527,1555 ****
 366   }
 367
 368       static PyObject *
 369 ! BufferItem(PyObject *self, int n)
 370   {
 371       return RBItem((BufferObject *)(self), n, 1,
 372                   (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);
 373   }
 374
 375       static PyObject *
 376 ! BufferSlice(PyObject *self, int lo, int hi)
 377   {
 378       return RBSlice((BufferObject *)(self), lo, hi, 1,
 379                    (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);
 380   }
 381
 382 !     static int
 383 ! BufferAssItem(PyObject *self, int n, PyObject *val)
 384   {
 385       return RBAssItem((BufferObject *)(self), n, val, 1,
 386                      (int)((BufferObject *)(self))->buf->b_ml.ml_line_count,
 387                      NULL);
 388   }
 389
 390 !     static int
 391 ! BufferAssSlice(PyObject *self, int lo, int hi, PyObject *val)
 392   {
 393       return RBAssSlice((BufferObject *)(self), lo, hi, val, 1,
 394                       (int)((BufferObject *)(self))->buf->b_ml.ml_line_count,
 395 --- 1555,1583 ----
 396   }
 397
 398       static PyObject *
 399 ! BufferItem(PyObject *self, PyInt n)
 400   {
 401       return RBItem((BufferObject *)(self), n, 1,
 402                   (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);
 403   }
 404
 405       static PyObject *
 406 ! BufferSlice(PyObject *self, PyInt lo, PyInt hi)
 407   {
 408       return RBSlice((BufferObject *)(self), lo, hi, 1,
 409                    (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);
 410   }
 411
 412 !     static PyInt
 413 ! BufferAssItem(PyObject *self, PyInt n, PyObject *val)
 414   {
 415       return RBAssItem((BufferObject *)(self), n, val, 1,
 416                      (int)((BufferObject *)(self))->buf->b_ml.ml_line_count,
 417                      NULL);
 418   }
 419
 420 !     static PyInt
 421 ! BufferAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
 422   {
 423       return RBAssSlice((BufferObject *)(self), lo, hi, val, 1,
 424                       (int)((BufferObject *)(self))->buf->b_ml.ml_line_count,
 425 ***************
 426 *** 1627,1639 ****
 427   };
 428
 429   static PySequenceMethods RangeAsSeq = {
 430 !     (inquiry)         RangeLength,        /* sq_length,    len(x)   */
 431       (binaryfunc)      0, /* RangeConcat, */        /* sq_concat,    x+y      */
 432 !     (intargfunc)      0, /* RangeRepeat, */        /* sq_repeat,    x*n      */
 433 !     (intargfunc)      RangeItem,          /* sq_item,      x[i]     */
 434 !     (intintargfunc)   RangeSlice,         /* sq_slice,     x[i:j]   */
 435 !     (intobjargproc)   RangeAssItem,       /* sq_ass_item,  x[i]=v   */
 436 !     (intintobjargproc)        RangeAssSlice,      /* sq_ass_slice, x[i:j]=v */
 437   };
 438
 439   static PyTypeObject RangeType = {
 440 --- 1655,1667 ----
 441   };
 442
 443   static PySequenceMethods RangeAsSeq = {
 444 !     (PyInquiry)               RangeLength,        /* sq_length,    len(x)   */
 445       (binaryfunc)      0, /* RangeConcat, */        /* sq_concat,    x+y      */
 446 !     (PyIntArgFunc)    0, /* RangeRepeat, */        /* sq_repeat,    x*n      */
 447 !     (PyIntArgFunc)    RangeItem,          /* sq_item,      x[i]     */
 448 !     (PyIntIntArgFunc) RangeSlice,         /* sq_slice,     x[i:j]   */
 449 !     (PyIntObjArgProc) RangeAssItem,       /* sq_ass_item,  x[i]=v   */
 450 !     (PyIntIntObjArgProc)      RangeAssSlice,      /* sq_ass_slice, x[i:j]=v */
 451   };
 452
 453   static PyTypeObject RangeType = {
 454 ***************
 455 *** 1738,1744 ****
 456
 457   /****************/
 458
 459 !     static int
 460   RangeLength(PyObject *self)
 461   {
 462       /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
 463 --- 1766,1772 ----
 464
 465   /****************/
 466
 467 !     static PyInt
 468   RangeLength(PyObject *self)
 469   {
 470       /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */
 471 ***************
 472 *** 1749,1755 ****
 473   }
 474
 475       static PyObject *
 476 ! RangeItem(PyObject *self, int n)
 477   {
 478       return RBItem(((RangeObject *)(self))->buf, n,
 479                   ((RangeObject *)(self))->start,
 480 --- 1777,1783 ----
 481   }
 482
 483       static PyObject *
 484 ! RangeItem(PyObject *self, PyInt n)
 485   {
 486       return RBItem(((RangeObject *)(self))->buf, n,
 487                   ((RangeObject *)(self))->start,
 488 ***************
 489 *** 1757,1771 ****
 490   }
 491
 492       static PyObject *
 493 ! RangeSlice(PyObject *self, int lo, int hi)
 494   {
 495       return RBSlice(((RangeObject *)(self))->buf, lo, hi,
 496                    ((RangeObject *)(self))->start,
 497                    ((RangeObject *)(self))->end);
 498   }
 499
 500 !     static int
 501 ! RangeAssItem(PyObject *self, int n, PyObject *val)
 502   {
 503       return RBAssItem(((RangeObject *)(self))->buf, n, val,
 504                      ((RangeObject *)(self))->start,
 505 --- 1785,1799 ----
 506   }
 507
 508       static PyObject *
 509 ! RangeSlice(PyObject *self, PyInt lo, PyInt hi)
 510   {
 511       return RBSlice(((RangeObject *)(self))->buf, lo, hi,
 512                    ((RangeObject *)(self))->start,
 513                    ((RangeObject *)(self))->end);
 514   }
 515
 516 !     static PyInt
 517 ! RangeAssItem(PyObject *self, PyInt n, PyObject *val)
 518   {
 519       return RBAssItem(((RangeObject *)(self))->buf, n, val,
 520                      ((RangeObject *)(self))->start,
 521 ***************
 522 *** 1773,1780 ****
 523                      &((RangeObject *)(self))->end);
 524   }
 525
 526 !     static int
 527 ! RangeAssSlice(PyObject *self, int lo, int hi, PyObject *val)
 528   {
 529       return RBAssSlice(((RangeObject *)(self))->buf, lo, hi, val,
 530                       ((RangeObject *)(self))->start,
 531 --- 1801,1808 ----
 532                      &((RangeObject *)(self))->end);
 533   }
 534
 535 !     static PyInt
 536 ! RangeAssSlice(PyObject *self, PyInt lo, PyInt hi, PyObject *val)
 537   {
 538       return RBAssSlice(((RangeObject *)(self))->buf, lo, hi, val,
 539                       ((RangeObject *)(self))->start,
 540 ***************
 541 *** 1801,1813 ****
 542   BufListObject;
 543
 544   static PySequenceMethods BufListAsSeq = {
 545 !     (inquiry)         BufListLength,      /* sq_length,    len(x)   */
 546       (binaryfunc)      0,                  /* sq_concat,    x+y      */
 547 !     (intargfunc)      0,                  /* sq_repeat,    x*n      */
 548 !     (intargfunc)      BufListItem,        /* sq_item,      x[i]     */
 549 !     (intintargfunc)   0,                  /* sq_slice,     x[i:j]   */
 550 !     (intobjargproc)   0,                  /* sq_ass_item,  x[i]=v   */
 551 !     (intintobjargproc)        0,                  /* sq_ass_slice, x[i:j]=v */
 552   };
 553
 554   static PyTypeObject BufListType = {
 555 --- 1829,1841 ----
 556   BufListObject;
 557
 558   static PySequenceMethods BufListAsSeq = {
 559 !     (PyInquiry)               BufListLength,      /* sq_length,    len(x)   */
 560       (binaryfunc)      0,                  /* sq_concat,    x+y      */
 561 !     (PyIntArgFunc)    0,                  /* sq_repeat,    x*n      */
 562 !     (PyIntArgFunc)    BufListItem,        /* sq_item,      x[i]     */
 563 !     (PyIntIntArgFunc) 0,                  /* sq_slice,     x[i:j]   */
 564 !     (PyIntObjArgProc) 0,                  /* sq_ass_item,  x[i]=v   */
 565 !     (PyIntIntObjArgProc)      0,                  /* sq_ass_slice, x[i:j]=v */
 566   };
 567
 568   static PyTypeObject BufListType = {
 569 ***************
 570 *** 1837,1843 ****
 571    */
 572
 573   /*ARGSUSED*/
 574 !     static int
 575   BufListLength(PyObject *self)
 576   {
 577       buf_T     *b = firstbuf;
 578 --- 1865,1871 ----
 579    */
 580
 581   /*ARGSUSED*/
 582 !     static PyInt
 583   BufListLength(PyObject *self)
 584   {
 585       buf_T     *b = firstbuf;
 586 ***************
 587 *** 1854,1860 ****
 588
 589   /*ARGSUSED*/
 590       static PyObject *
 591 ! BufListItem(PyObject *self, int n)
 592   {
 593       buf_T *b;
 594
 595 --- 1882,1888 ----
 596
 597   /*ARGSUSED*/
 598       static PyObject *
 599 ! BufListItem(PyObject *self, PyInt n)
 600   {
 601       buf_T *b;
 602
 603 ***************
 604 *** 2119,2131 ****
 605   WinListObject;
 606
 607   static PySequenceMethods WinListAsSeq = {
 608 !     (inquiry)         WinListLength,      /* sq_length,    len(x)   */
 609       (binaryfunc)      0,                  /* sq_concat,    x+y      */
 610 !     (intargfunc)      0,                  /* sq_repeat,    x*n      */
 611 !     (intargfunc)      WinListItem,        /* sq_item,      x[i]     */
 612 !     (intintargfunc)   0,                  /* sq_slice,     x[i:j]   */
 613 !     (intobjargproc)   0,                  /* sq_ass_item,  x[i]=v   */
 614 !     (intintobjargproc)        0,                  /* sq_ass_slice, x[i:j]=v */
 615   };
 616
 617   static PyTypeObject WinListType = {
 618 --- 2147,2159 ----
 619   WinListObject;
 620
 621   static PySequenceMethods WinListAsSeq = {
 622 !     (PyInquiry)               WinListLength,      /* sq_length,    len(x)   */
 623       (binaryfunc)      0,                  /* sq_concat,    x+y      */
 624 !     (PyIntArgFunc)    0,                  /* sq_repeat,    x*n      */
 625 !     (PyIntArgFunc)    WinListItem,        /* sq_item,      x[i]     */
 626 !     (PyIntIntArgFunc) 0,                  /* sq_slice,     x[i:j]   */
 627 !     (PyIntObjArgProc) 0,                  /* sq_ass_item,  x[i]=v   */
 628 !     (PyIntIntObjArgProc)      0,                  /* sq_ass_slice, x[i:j]=v */
 629   };
 630
 631   static PyTypeObject WinListType = {
 632 ***************
 633 *** 2154,2160 ****
 634   /* Window list object - Implementation
 635    */
 636   /*ARGSUSED*/
 637 !     static int
 638   WinListLength(PyObject *self)
 639   {
 640       win_T     *w = firstwin;
 641 --- 2182,2188 ----
 642   /* Window list object - Implementation
 643    */
 644   /*ARGSUSED*/
 645 !     static PyInt
 646   WinListLength(PyObject *self)
 647   {
 648       win_T     *w = firstwin;
 649 ***************
 650 *** 2171,2177 ****
 651
 652   /*ARGSUSED*/
 653       static PyObject *
 654 ! WinListItem(PyObject *self, int n)
 655   {
 656       win_T *w;
 657
 658 --- 2199,2205 ----
 659
 660   /*ARGSUSED*/
 661       static PyObject *
 662 ! WinListItem(PyObject *self, PyInt n)
 663   {
 664       win_T *w;
 665
 666 ***************
 667 *** 2351,2360 ****
 668    * including, hi. The list is returned as a Python list of string objects.
 669    */
 670       static PyObject *
 671 ! GetBufferLineList(buf_T *buf, int lo, int hi)
 672   {
 673 !     int i;
 674 !     int n = hi - lo;
 675       PyObject *list = PyList_New(n);
 676
 677       if (list == NULL)
 678 --- 2379,2388 ----
 679    * including, hi. The list is returned as a Python list of string objects.
 680    */
 681       static PyObject *
 682 ! GetBufferLineList(buf_T *buf, PyInt lo, PyInt hi)
 683   {
 684 !     PyInt i;
 685 !     PyInt n = hi - lo;
 686       PyObject *list = PyList_New(n);
 687
 688       if (list == NULL)
 689 ***************
 690 *** 2517,2523 ****
 691    * is set to the change in the buffer length.
 692    */
 693       static int
 694 ! SetBufferLineList(buf_T *buf, int lo, int hi, PyObject *list, int *len_change)
 695   {
 696       /* First of all, we check the thpe of the supplied Python object.
 697        * There are three cases:
 698 --- 2545,2551 ----
 699    * is set to the change in the buffer length.
 700    */
 701       static int
 702 ! SetBufferLineList(buf_T *buf, PyInt lo, PyInt hi, PyObject *list, int *len_change)
 703   {
 704       /* First of all, we check the thpe of the supplied Python object.
 705        * There are three cases:
 706 ***************
 707 *** 2527,2534 ****
 708        */
 709       if (list == Py_None || list == NULL)
 710       {
 711 !       int     i;
 712 !       int     n = hi - lo;
 713         buf_T   *savebuf = curbuf;
 714
 715         PyErr_Clear();
 716 --- 2555,2562 ----
 717        */
 718       if (list == Py_None || list == NULL)
 719       {
 720 !       PyInt   i;
 721 !       PyInt   n = hi - lo;
 722         buf_T   *savebuf = curbuf;
 723
 724         PyErr_Clear();
 725 ***************
 726 *** 2564,2572 ****
 727       }
 728       else if (PyList_Check(list))
 729       {
 730 !       int     i;
 731 !       int     new_len = PyList_Size(list);
 732 !       int     old_len = hi - lo;
 733         int     extra = 0;      /* lines added to text, can be negative */
 734         char    **array;
 735         buf_T   *savebuf;
 736 --- 2592,2600 ----
 737       }
 738       else if (PyList_Check(list))
 739       {
 740 !       PyInt   i;
 741 !       PyInt   new_len = PyList_Size(list);
 742 !       PyInt   old_len = hi - lo;
 743         int     extra = 0;      /* lines added to text, can be negative */
 744         char    **array;
 745         buf_T   *savebuf;
 746 ***************
 747 *** 2745,2752 ****
 748       }
 749       else if (PyList_Check(lines))
 750       {
 751 !       int     i;
 752 !       int     size = PyList_Size(lines);
 753         char    **array;
 754         buf_T   *savebuf;
 755
 756 --- 2773,2780 ----
 757       }
 758       else if (PyList_Check(lines))
 759       {
 760 !       PyInt   i;
 761 !       PyInt   size = PyList_Size(lines);
 762         char    **array;
 763         buf_T   *savebuf;
 764
 765 ***************
 766 *** 2831,2837 ****
 767   LineToString(const char *str)
 768   {
 769       PyObject *result;
 770 !     int len = strlen(str);
 771       char *p;
 772
 773       /* Allocate an Python string object, with uninitialised contents. We
 774 --- 2859,2865 ----
 775   LineToString(const char *str)
 776   {
 777       PyObject *result;
 778 !     PyInt len = strlen(str);
 779       char *p;
 780
 781       /* Allocate an Python string object, with uninitialised contents. We
 782 ***************
 783 *** 2871,2878 ****
 784   {
 785       const char *str;
 786       char *save;
 787 !     int len;
 788 !     int i;
 789       char *p;
 790
 791       if (obj == NULL || !PyString_Check(obj))
 792 --- 2899,2906 ----
 793   {
 794       const char *str;
 795       char *save;
 796 !     PyInt len;
 797 !     PyInt i;
 798       char *p;
 799
 800       if (obj == NULL || !PyString_Check(obj))
 801 *** ../vim-7.1.306/src/version.c        Wed Jun  4 10:59:18 2008
 802 --- src/version.c       Wed Jun  4 13:31:40 2008
 803 ***************
 804 *** 668,669 ****
 805 --- 673,676 ----
 806   {   /* Add new patch number below this line */
 807 + /**/
 808 +     307,
 809   /**/
 810
 811 --
 812 For humans, honesty is a matter of degree.  Engineers are always honest in
 813 matters of technology and human relationships.  That's why it's a good idea
 814 to keep engineers away from customers, romantic interests, and other people
 815 who can't handle the truth.
 816                                 (Scott Adams - The Dilbert principle)
 817
 818  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
 819 ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
 820 \\\        download, build and distribute -- http://www.A-A-P.org        ///
 821  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///