To: vim_dev@googlegroups.com

Subject: Patch 7.3.937

Fcc: outbox

From: Bram Moolenaar <Bram@moolenaar.net>

Mime-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

------------

Patch 7.3.937

Problem:    More can be shared between Python 2 and 3.

Solution:   Move code to if_py_both.h. (ZyX)

Files:	    src/if_python.c, src/if_python3.c, src/if_py_both.h

*** ../vim-7.3.936/src/if_python.c	2013-05-06 04:21:35.000000000 +0200

--- src/if_python.c	2013-05-12 18:31:20.000000000 +0200

***************

*** 619,624 ****

--- 619,627 ----

  #define DESTRUCTOR_FINISH(self) Py_DECREF(self);

+ #define WIN_PYTHON_REF(win) win->w_python_ref

+ #define BUF_PYTHON_REF(buf) buf->b_python_ref

+ 

  static PyObject *OutputGetattr(PyObject *, char *);

  static PyObject *BufferGetattr(PyObject *, char *);

  static PyObject *WindowGetattr(PyObject *, char *);

***************

*** 1054,1095 ****

   */

      static PyObject *

- BufferNew(buf_T *buf)

- {

-     /* We need to handle deletion of buffers underneath us.

-      * If we add a "b_python_ref" field to the buf_T structure,

-      * then we can get at it in buf_freeall() in vim. We then

-      * need to create only ONE Python object per buffer - if

-      * we try to create a second, just INCREF the existing one

-      * and return it. The (single) Python object referring to

-      * the buffer is stored in "b_python_ref".

-      * Question: what to do on a buf_freeall(). We'll probably

-      * have to either delete the Python object (DECREF it to

-      * zero - a bad idea, as it leaves dangling refs!) or

-      * set the buf_T * value to an invalid value (-1?), which

-      * means we need checks in all access functions... Bah.

-      */

- 

-     BufferObject *self;

- 

-     if (buf->b_python_ref != NULL)

-     {

- 	self = buf->b_python_ref;

- 	Py_INCREF(self);

-     }

-     else

-     {

- 	self = PyObject_NEW(BufferObject, &BufferType);

- 	if (self == NULL)

- 	    return NULL;

- 	self->buf = buf;

- 	buf->b_python_ref = self;

-     }

- 

-     return (PyObject *)(self);

- }

- 

-     static PyObject *

  BufferGetattr(PyObject *self, char *name)

  {

      PyObject *r;

--- 1057,1062 ----

***************

*** 1107,1136 ****

  /******************/

      static PyInt

- BufferLength(PyObject *self)

- {

-     /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */

-     if (CheckBuffer((BufferObject *)(self)))

- 	return -1; /* ??? */

- 

-     return (((BufferObject *)(self))->buf->b_ml.ml_line_count);

- }

- 

-     static PyObject *

- BufferItem(PyObject *self, PyInt n)

- {

-     return RBItem((BufferObject *)(self), n, 1,

- 		  (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);

- }

- 

-     static PyObject *

- BufferSlice(PyObject *self, PyInt lo, PyInt hi)

- {

-     return RBSlice((BufferObject *)(self), lo, hi, 1,

- 		   (int)((BufferObject *)(self))->buf->b_ml.ml_line_count);

- }

- 

-     static PyInt

  BufferAssItem(PyObject *self, PyInt n, PyObject *val)

  {

      return RBAsItem((BufferObject *)(self), n, val, 1,

--- 1074,1079 ----

***************

*** 1217,1256 ****

   */

      static PyObject *

- WindowNew(win_T *win)

- {

-     /* We need to handle deletion of windows underneath us.

-      * If we add a "w_python_ref" field to the win_T structure,

-      * then we can get at it in win_free() in vim. We then

-      * need to create only ONE Python object per window - if

-      * we try to create a second, just INCREF the existing one

-      * and return it. The (single) Python object referring to

-      * the window is stored in "w_python_ref".

-      * On a win_free() we set the Python object's win_T* field

-      * to an invalid value. We trap all uses of a window

-      * object, and reject them if the win_T* field is invalid.

-      */

- 

-     WindowObject *self;

- 

-     if (win->w_python_ref)

-     {

- 	self = win->w_python_ref;

- 	Py_INCREF(self);

-     }

-     else

-     {

- 	self = PyObject_NEW(WindowObject, &WindowType);

- 	if (self == NULL)

- 	    return NULL;

- 	self->win = win;

- 	win->w_python_ref = self;

-     }

- 

-     return (PyObject *)(self);

- }

- 

-     static PyObject *

  WindowGetattr(PyObject *self, char *name)

  {

      PyObject *r;

--- 1160,1165 ----

***************

*** 1289,1299 ****

      void

  python_buffer_free(buf_T *buf)

  {

!     if (buf->b_python_ref != NULL)

      {

! 	BufferObject *bp = buf->b_python_ref;

  	bp->buf = INVALID_BUFFER_VALUE;

! 	buf->b_python_ref = NULL;

      }

  }

--- 1198,1208 ----

      void

  python_buffer_free(buf_T *buf)

  {

!     if (BUF_PYTHON_REF(buf) != NULL)

      {

! 	BufferObject *bp = BUF_PYTHON_REF(buf);

  	bp->buf = INVALID_BUFFER_VALUE;

! 	BUF_PYTHON_REF(buf) = NULL;

      }

  }

***************

*** 1301,1311 ****

      void

  python_window_free(win_T *win)

  {

!     if (win->w_python_ref != NULL)

      {

! 	WindowObject *wp = win->w_python_ref;

  	wp->win = INVALID_WINDOW_VALUE;

! 	win->w_python_ref = NULL;

      }

  }

  #endif

--- 1210,1220 ----

      void

  python_window_free(win_T *win)

  {

!     if (WIN_PYTHON_REF(win) != NULL)

      {

! 	WindowObject *wp = WIN_PYTHON_REF(win);

  	wp->win = INVALID_WINDOW_VALUE;

! 	WIN_PYTHON_REF(win) = NULL;

      }

  }

  #endif

*** ../vim-7.3.936/src/if_python3.c	2013-05-06 04:21:35.000000000 +0200

--- src/if_python3.c	2013-05-12 18:31:20.000000000 +0200

***************

*** 621,626 ****

--- 621,629 ----

  #define DESTRUCTOR_FINISH(self) Py_TYPE(self)->tp_free((PyObject*)self);

+ #define WIN_PYTHON_REF(win) win->w_python3_ref

+ #define BUF_PYTHON_REF(buf) buf->b_python3_ref

+ 

      static void

  call_PyObject_Free(void *p)

  {

***************

*** 1067,1112 ****

  };

! /* Buffer object - Definitions

   */

      static PyObject *

- BufferNew(buf_T *buf)

- {

-     /* We need to handle deletion of buffers underneath us.

-      * If we add a "b_python3_ref" field to the buf_T structure,

-      * then we can get at it in buf_freeall() in vim. We then

-      * need to create only ONE Python object per buffer - if

-      * we try to create a second, just INCREF the existing one

-      * and return it. The (single) Python object referring to

-      * the buffer is stored in "b_python3_ref".

-      * Question: what to do on a buf_freeall(). We'll probably

-      * have to either delete the Python object (DECREF it to

-      * zero - a bad idea, as it leaves dangling refs!) or

-      * set the buf_T * value to an invalid value (-1?), which

-      * means we need checks in all access functions... Bah.

-      */

- 

-     BufferObject *self;

- 

-     if (buf->b_python3_ref != NULL)

-     {

- 	self = buf->b_python3_ref;

- 	Py_INCREF(self);

-     }

-     else

-     {

- 	self = PyObject_NEW(BufferObject, &BufferType);

- 	buf->b_python3_ref = self;

- 	if (self == NULL)

- 	    return NULL;

- 	self->buf = buf;

-     }

- 

-     return (PyObject *)(self);

- }

- 

-     static PyObject *

  BufferGetattro(PyObject *self, PyObject*nameobj)

  {

      PyObject *r;

--- 1070,1079 ----

  };

! /* Buffer object

   */

      static PyObject *

  BufferGetattro(PyObject *self, PyObject*nameobj)

  {

      PyObject *r;

***************

*** 1132,1160 ****

  /******************/

-     static Py_ssize_t

- BufferLength(PyObject *self)

- {

-     if (CheckBuffer((BufferObject *)(self)))

- 	return -1;

- 

-     return (Py_ssize_t)(((BufferObject *)(self))->buf->b_ml.ml_line_count);

- }

- 

-     static PyObject *

- BufferItem(PyObject *self, Py_ssize_t n)

- {

-     return RBItem((BufferObject *)(self), n, 1,

- 	       (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count);

- }

- 

-     static PyObject *

- BufferSlice(PyObject *self, Py_ssize_t lo, Py_ssize_t hi)

- {

-     return RBSlice((BufferObject *)(self), lo, hi, 1,

- 	       (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count);

- }

- 

      static PyObject *

  BufferSubscript(PyObject *self, PyObject* idx)

  {

--- 1099,1104 ----

***************

*** 1342,1381 ****

   */

      static PyObject *

- WindowNew(win_T *win)

- {

-     /* We need to handle deletion of windows underneath us.

-      * If we add a "w_python3_ref" field to the win_T structure,

-      * then we can get at it in win_free() in vim. We then

-      * need to create only ONE Python object per window - if

-      * we try to create a second, just INCREF the existing one

-      * and return it. The (single) Python object referring to

-      * the window is stored in "w_python3_ref".

-      * On a win_free() we set the Python object's win_T* field

-      * to an invalid value. We trap all uses of a window

-      * object, and reject them if the win_T* field is invalid.

-      */

- 

-     WindowObject *self;

- 

-     if (win->w_python3_ref)

-     {

- 	self = win->w_python3_ref;

- 	Py_INCREF(self);

-     }

-     else

-     {

- 	self = PyObject_NEW(WindowObject, &WindowType);

- 	if (self == NULL)

- 	    return NULL;

- 	self->win = win;

- 	win->w_python3_ref = self;

-     }

- 

-     return (PyObject *)(self);

- }

- 

-     static PyObject *

  WindowGetattro(PyObject *self, PyObject *nameobj)

  {

      PyObject *r;

--- 1286,1291 ----

***************

*** 1575,1585 ****

      void

  python3_buffer_free(buf_T *buf)

  {

!     if (buf->b_python3_ref != NULL)

      {

! 	BufferObject *bp = buf->b_python3_ref;

  	bp->buf = INVALID_BUFFER_VALUE;

! 	buf->b_python3_ref = NULL;

      }

  }

--- 1485,1495 ----

      void

  python3_buffer_free(buf_T *buf)

  {

!     if (BUF_PYTHON_REF(buf) != NULL)

      {

! 	BufferObject *bp = BUF_PYTHON_REF(buf);

  	bp->buf = INVALID_BUFFER_VALUE;

! 	BUF_PYTHON_REF(buf) = NULL;

      }

  }

***************

*** 1587,1597 ****

      void

  python3_window_free(win_T *win)

  {

!     if (win->w_python3_ref != NULL)

      {

! 	WindowObject *wp = win->w_python3_ref;

  	wp->win = INVALID_WINDOW_VALUE;

! 	win->w_python3_ref = NULL;

      }

  }

  #endif

--- 1497,1507 ----

      void

  python3_window_free(win_T *win)

  {

!     if (WIN_PYTHON_REF(win) != NULL)

      {

! 	WindowObject *wp = WIN_PYTHON_REF(win);

  	wp->win = INVALID_WINDOW_VALUE;

! 	WIN_PYTHON_REF(win) = NULL;

      }

  }

  #endif

*** ../vim-7.3.936/src/if_py_both.h	2013-05-06 06:26:10.000000000 +0200

--- src/if_py_both.h	2013-05-12 18:31:20.000000000 +0200

***************

*** 1782,1792 ****

--- 1782,1832 ----

      return 0;

  }

+ /* Window object

+  */

+ 

  static int WindowSetattr(PyObject *, char *, PyObject *);

  static PyObject *WindowRepr(PyObject *);

  static PyTypeObject WindowType;

      static PyObject *

+ WindowNew(win_T *win)

+ {

+     /* We need to handle deletion of windows underneath us.

+      * If we add a "w_python*_ref" field to the win_T structure,

+      * then we can get at it in win_free() in vim. We then

+      * need to create only ONE Python object per window - if

+      * we try to create a second, just INCREF the existing one

+      * and return it. The (single) Python object referring to

+      * the window is stored in "w_python*_ref".

+      * On a win_free() we set the Python object's win_T* field

+      * to an invalid value. We trap all uses of a window

+      * object, and reject them if the win_T* field is invalid.

+      *

+      * Python2 and Python3 get different fields and different objects: 

+      * w_python_ref and w_python3_ref fields respectively.

+      */

+ 

+     WindowObject *self;

+ 

+     if (WIN_PYTHON_REF(win))

+     {

+ 	self = WIN_PYTHON_REF(win);

+ 	Py_INCREF(self);

+     }

+     else

+     {

+ 	self = PyObject_NEW(WindowObject, &WindowType);

+ 	if (self == NULL)

+ 	    return NULL;

+ 	self->win = win;

+ 	WIN_PYTHON_REF(win) = self;

+     }

+ 

+     return (PyObject *)(self);

+ }

+ 

+     static PyObject *

  WindowAttr(WindowObject *this, char *name)

  {

      if (strcmp(name, "buffer") == 0)

***************

*** 1809,1815 ****

  	return OptionsNew(SREQ_WIN, this->win, (checkfun) CheckWindow,

  			(PyObject *) this);

      else if (strcmp(name,"__members__") == 0)

! 	return Py_BuildValue("[sssss]", "buffer", "cursor", "height", "vars",

  		"options");

      else

  	return NULL;

--- 1849,1855 ----

  	return OptionsNew(SREQ_WIN, this->win, (checkfun) CheckWindow,

  			(PyObject *) this);

      else if (strcmp(name,"__members__") == 0)

! 	return Py_BuildValue("[ssssss]", "buffer", "cursor", "height", "vars",

  		"options");

      else

  	return NULL;

***************

*** 1821,1831 ****

      WindowObject *this = (WindowObject *)(self);

      if (this->win && this->win != INVALID_WINDOW_VALUE)

! #if PY_MAJOR_VERSION >= 3

! 	this->win->w_python3_ref = NULL;

! #else

! 	this->win->w_python_ref = NULL;

! #endif

      DESTRUCTOR_FINISH(self);

  }

--- 1861,1867 ----

      WindowObject *this = (WindowObject *)(self);

      if (this->win && this->win != INVALID_WINDOW_VALUE)

! 	WIN_PYTHON_REF(this->win) = NULL;

      DESTRUCTOR_FINISH(self);

  }

***************

*** 2756,2771 ****

      BufferObject *this = (BufferObject *)(self);

      if (this->buf && this->buf != INVALID_BUFFER_VALUE)

! #if PY_MAJOR_VERSION >= 3

! 	this->buf->b_python3_ref = NULL;

! #else

! 	this->buf->b_python_ref = NULL;

! #endif

      DESTRUCTOR_FINISH(self);

  }

      static PyObject *

  BufferAttr(BufferObject *this, char *name)

  {

      if (strcmp(name, "name") == 0)

--- 2792,2842 ----

      BufferObject *this = (BufferObject *)(self);

      if (this->buf && this->buf != INVALID_BUFFER_VALUE)

! 	BUF_PYTHON_REF(this->buf) = NULL;

      DESTRUCTOR_FINISH(self);

  }

      static PyObject *

+ BufferNew(buf_T *buf)

+ {

+     /* We need to handle deletion of buffers underneath us.

+      * If we add a "b_python*_ref" field to the buf_T structure,

+      * then we can get at it in buf_freeall() in vim. We then

+      * need to create only ONE Python object per buffer - if

+      * we try to create a second, just INCREF the existing one

+      * and return it. The (single) Python object referring to

+      * the buffer is stored in "b_python*_ref".

+      * Question: what to do on a buf_freeall(). We'll probably

+      * have to either delete the Python object (DECREF it to

+      * zero - a bad idea, as it leaves dangling refs!) or

+      * set the buf_T * value to an invalid value (-1?), which

+      * means we need checks in all access functions... Bah.

+      *

+      * Python2 and Python3 get different fields and different objects: 

+      * b_python_ref and b_python3_ref fields respectively.

+      */

+ 

+     BufferObject *self;

+ 

+     if (BUF_PYTHON_REF(buf) != NULL)

+     {

+ 	self = BUF_PYTHON_REF(buf);

+ 	Py_INCREF(self);

+     }

+     else

+     {

+ 	self = PyObject_NEW(BufferObject, &BufferType);

+ 	if (self == NULL)

+ 	    return NULL;

+ 	self->buf = buf;

+ 	BUF_PYTHON_REF(buf) = self;

+     }

+ 

+     return (PyObject *)(self);

+ }

+ 

+     static PyObject *

  BufferAttr(BufferObject *this, char *name)

  {

      if (strcmp(name, "name") == 0)

***************

*** 2783,2788 ****

--- 2854,2883 ----

  	return NULL;

  }

+     static PyInt

+ BufferLength(PyObject *self)

+ {

+     /* HOW DO WE SIGNAL AN ERROR FROM THIS FUNCTION? */

+     if (CheckBuffer((BufferObject *)(self)))

+ 	return -1; /* ??? */

+ 

+     return (PyInt)(((BufferObject *)(self))->buf->b_ml.ml_line_count);

+ }

+ 

+     static PyObject *

+ BufferItem(PyObject *self, PyInt n)

+ {

+     return RBItem((BufferObject *)(self), n, 1,

+ 		  (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count);

+ }

+ 

+     static PyObject *

+ BufferSlice(PyObject *self, PyInt lo, PyInt hi)

+ {

+     return RBSlice((BufferObject *)(self), lo, hi, 1,

+ 		   (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count);

+ }

+ 

      static PyObject *

  BufferAppend(PyObject *self, PyObject *args)

  {

*** ../vim-7.3.936/src/version.c	2013-05-12 14:10:41.000000000 +0200

--- src/version.c	2013-05-12 18:44:01.000000000 +0200

***************

*** 730,731 ****

--- 730,733 ----

  {   /* Add new patch number below this line */

+ /**/

+     937,

  /**/

-- 

ARTHUR:  Well, I can't just call you `Man'.

DENNIS:  Well, you could say `Dennis'.

ARTHUR:  Well, I didn't know you were called `Dennis.'

DENNIS:  Well, you didn't bother to find out, did you?

                                  The Quest for the Holy Grail (Monty Python)

 /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\

///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\

\\\  an exciting new programming language -- http://www.Zimbu.org        ///

 \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///