Loading ...
Sorry, an error occurred while loading the content.
 

Patch 7.3.937

Expand Messages
  • Bram Moolenaar
    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,
    Message 1 of 1 , May 12, 2013
      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@... -- 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 ///

      --
      --
      You received this message from the "vim_dev" maillist.
      Do not top-post! Type your reply below the text you are replying to.
      For more information, visit http://www.vim.org/maillist.php

      ---
      You received this message because you are subscribed to the Google Groups "vim_dev" group.
      To unsubscribe from this group and stop receiving emails from it, send an email to vim_dev+unsubscribe@....
      For more options, visit https://groups.google.com/groups/opt_out.
    Your message has been successfully submitted and would be delivered to recipients shortly.