To: vim_dev@googlegroups.com

Subject: Patch 7.3.909

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.909

Problem:    Duplicate Python code.

Solution:   Move more items to if_py_both.h. (ZyX)  Also avoid compiler

	    warnings for missing initializers.

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

*** ../vim-7.3.908/src/if_py_both.h	2013-04-24 13:10:35.000000000 +0200

--- src/if_py_both.h	2013-04-24 13:26:54.000000000 +0200

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

*** 542,547 ****

--- 542,555 ----

   * Buffer list object - Implementation

   */

+ typedef struct

+ {

+     PyObject_HEAD

+ } BufListObject;

+ 

+ static PyTypeObject BufListType;

+ static PySequenceMethods WinListAsSeq;

+ 

      static PyInt

  BufListLength(PyObject *self UNUSED)

  {

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

*** 578,583 ****

--- 586,596 ----

      win_T	*win;

  } WindowObject;

+ static struct PyMethodDef WindowMethods[] = {

+     /* name,	    function,		calling,    documentation */

+     { NULL,	    NULL,		0,	    NULL }

+ };

+ 

  static int ConvertFromPyObject(PyObject *, typval_T *);

  static int _ConvertFromPyObject(PyObject *, typval_T *, PyObject *);

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

*** 642,647 ****

--- 655,670 ----

      pylinkedlist_T	ref;

  } DictionaryObject;

+ static PyInt DictionaryAssItem(PyObject *, PyObject *, PyObject *);

+ static PyInt DictionaryLength(PyObject *);

+ static PyObject *DictionaryItem(PyObject *, PyObject *);

+ 

+ static PyMappingMethods DictionaryAsMapping = {

+     (lenfunc)       DictionaryLength,

+     (binaryfunc)    DictionaryItem,

+     (objobjargproc) DictionaryAssItem,

+ };

+ 

      static PyObject *

  DictionaryNew(dict_T *dict)

  {

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

*** 658,663 ****

--- 681,697 ----

      return (PyObject *)(self);

  }

+     static void

+ DictionaryDestructor(PyObject *self)

+ {

+     DictionaryObject	*this = ((DictionaryObject *) (self));

+ 

+     pyll_remove(&this->ref, &lastdict);

+     dict_unref(this->dict);

+ 

+     DESTRUCTOR_FINISH(self);

+ }

+ 

      static int

  pydict_to_tv(PyObject *obj, typval_T *tv, PyObject *lookupDict)

  {

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

*** 804,812 ****

      return 0;

  }

!     static PyInt

! DictionarySetattr(DictionaryObject *self, char *name, PyObject *val)

  {

      if (val == NULL)

      {

  	PyErr_SetString(PyExc_AttributeError, _("Cannot delete DictionaryObject attributes"));

--- 838,848 ----

      return 0;

  }

!     static int

! DictionarySetattr(PyObject *self, char *name, PyObject *val)

  {

+     DictionaryObject *this = (DictionaryObject *)(self);

+ 

      if (val == NULL)

      {

  	PyErr_SetString(PyExc_AttributeError, _("Cannot delete DictionaryObject attributes"));

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

*** 815,821 ****

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

      {

! 	if (self->dict->dv_lock == VAR_FIXED)

  	{

  	    PyErr_SetString(PyExc_TypeError, _("Cannot modify fixed dictionary"));

  	    return -1;

--- 851,857 ----

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

      {

! 	if (this->dict->dv_lock == VAR_FIXED)

  	{

  	    PyErr_SetString(PyExc_TypeError, _("Cannot modify fixed dictionary"));

  	    return -1;

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

*** 829,837 ****

  	    }

  	    if (val == Py_True)

! 		self->dict->dv_lock = VAR_LOCKED;

  	    else

! 		self->dict->dv_lock = 0;

  	}

  	return 0;

      }

--- 865,873 ----

  	    }

  	    if (val == Py_True)

! 		this->dict->dv_lock = VAR_LOCKED;

  	    else

! 		this->dict->dv_lock = 0;

  	}

  	return 0;

      }

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

*** 963,968 ****

--- 999,1006 ----

  };

  static PyTypeObject ListType;

+ static PySequenceMethods ListAsSeq;

+ static PyMappingMethods ListAsMapping;

  typedef struct

  {

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

*** 987,992 ****

--- 1025,1041 ----

      return (PyObject *)(self);

  }

+     static void

+ ListDestructor(PyObject *self)

+ {

+     ListObject *this = (ListObject *)(self);

+ 

+     pyll_remove(&this->ref, &lastlist);

+     list_unref(this->list);

+ 

+     DESTRUCTOR_FINISH(self);

+ }

+ 

      static int

  list_py_concat(list_T *l, PyObject *obj, PyObject *lookupDict)

  {

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

*** 1307,1314 ****

  }

      static int

! ListSetattr(ListObject *self, char *name, PyObject *val)

  {

      if (val == NULL)

      {

  	PyErr_SetString(PyExc_AttributeError, _("Cannot delete DictionaryObject attributes"));

--- 1356,1365 ----

  }

      static int

! ListSetattr(PyObject *self, char *name, PyObject *val)

  {

+     ListObject *this = (ListObject *)(self);

+ 

      if (val == NULL)

      {

  	PyErr_SetString(PyExc_AttributeError, _("Cannot delete DictionaryObject attributes"));

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

*** 1317,1323 ****

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

      {

! 	if (self->list->lv_lock == VAR_FIXED)

  	{

  	    PyErr_SetString(PyExc_TypeError, _("Cannot modify fixed list"));

  	    return -1;

--- 1368,1374 ----

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

      {

! 	if (this->list->lv_lock == VAR_FIXED)

  	{

  	    PyErr_SetString(PyExc_TypeError, _("Cannot modify fixed list"));

  	    return -1;

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

*** 1331,1339 ****

  	    }

  	    if (val == Py_True)

! 		self->list->lv_lock = VAR_LOCKED;

  	    else

! 		self->list->lv_lock = 0;

  	}

  	return 0;

      }

--- 1382,1390 ----

  	    }

  	    if (val == Py_True)

! 		this->list->lv_lock = VAR_LOCKED;

  	    else

! 		this->list->lv_lock = 0;

  	}

  	return 0;

      }

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

*** 1376,1381 ****

--- 1427,1443 ----

      return (PyObject *)(self);

  }

+     static void

+ FunctionDestructor(PyObject *self)

+ {

+     FunctionObject	*this = (FunctionObject *) (self);

+ 

+     func_unref(this->name);

+     PyMem_Del(this->name);

+ 

+     DESTRUCTOR_FINISH(self);

+ }

+ 

      static PyObject *

  FunctionCall(PyObject *self, PyObject *argsObject, PyObject *kwargs)

  {

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

*** 1451,1456 ****

--- 1513,1557 ----

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

  static PyObject *WindowRepr(PyObject *);

+ static PyTypeObject WindowType;

+ 

+     static PyObject *

+ WindowAttr(WindowObject *this, char *name)

+ {

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

+ 	return (PyObject *)BufferNew(this->win->w_buffer);

+     else if (strcmp(name, "cursor") == 0)

+     {

+ 	pos_T *pos = &this->win->w_cursor;

+ 

+ 	return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));

+     }

+     else if (strcmp(name, "height") == 0)

+ 	return Py_BuildValue("l", (long)(this->win->w_height));

+ #ifdef FEAT_VERTSPLIT

+     else if (strcmp(name, "width") == 0)

+ 	return Py_BuildValue("l", (long)(W_WIDTH(this->win)));

+ #endif

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

+ 	return Py_BuildValue("[sss]", "buffer", "cursor", "height");

+     else

+ 	return NULL;

+ }

+ 

+     static void

+ WindowDestructor(PyObject *self)

+ {

+     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);

+ }

      static int

  WindowSetattr(PyObject *self, char *name, PyObject *val)

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

*** 1579,1584 ****

--- 1680,1694 ----

  /*

   * Window list object - Implementation

   */

+ 

+ typedef struct

+ {

+     PyObject_HEAD

+ } WinListObject;

+ 

+ static PyTypeObject WinListType;

+ static PySequenceMethods BufListAsSeq;

+ 

      static PyInt

  WinListLength(PyObject *self UNUSED)

  {

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

*** 2310,2319 ****

      return Py_None;

  }

! 

! /* Buffer object - Definitions

   */

  typedef struct

  {

      PyObject_HEAD

--- 2420,2430 ----

      return Py_None;

  }

! /* Range object - Definitions

   */

+ static PyTypeObject RangeType;

+ 

  typedef struct

  {

      PyObject_HEAD

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

*** 2322,2327 ****

--- 2433,2442 ----

      PyInt end;

  } RangeObject;

+ static void RangeDestructor(PyObject *);

+ static PySequenceMethods RangeAsSeq;

+ static PyMappingMethods RangeAsMapping;

+ 

      static PyObject *

  RangeNew(buf_T *buf, PyInt start, PyInt end)

  {

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

*** 2346,2351 ****

--- 2461,2506 ----

      return (PyObject *)(self);

  }

+     static void

+ RangeDestructor(PyObject *self)

+ {

+     Py_DECREF(((RangeObject *)(self))->buf);

+     DESTRUCTOR_FINISH(self);

+ }

+ 

+ static PyTypeObject BufferType;

+ static PyObject *BufferRepr(PyObject *);

+ static PySequenceMethods BufferAsSeq;

+ static PyMappingMethods BufferAsMapping;

+ 

+     static void

+ BufferDestructor(PyObject *self)

+ {

+     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)

+ 	return Py_BuildValue("s", this->buf->b_ffname);

+     else if (strcmp(name, "number") == 0)

+ 	return Py_BuildValue(Py_ssize_t_fmt, this->buf->b_fnum);

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

+ 	return Py_BuildValue("[ss]", "name", "number");

+     else

+ 	return NULL;

+ }

+ 

      static PyObject *

  BufferAppend(PyObject *self, PyObject *args)

  {

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

*** 2409,2414 ****

--- 2564,2598 ----

      return RangeNew(((BufferObject *)(self))->buf, start, end);

  }

+     static PyObject *

+ BufferRepr(PyObject *self)

+ {

+     static char repr[100];

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

+ 

+     if (this->buf == INVALID_BUFFER_VALUE)

+     {

+ 	vim_snprintf(repr, 100, _("<buffer object (deleted) at %p>"), (self));

+ 	return PyString_FromString(repr);

+     }

+     else

+     {

+ 	char *name = (char *)this->buf->b_fname;

+ 	PyInt len;

+ 

+ 	if (name == NULL)

+ 	    name = "";

+ 	len = strlen(name);

+ 

+ 	if (len > 35)

+ 	    name = name + (35 - len);

+ 

+ 	vim_snprintf(repr, 100, "<buffer %s%s>", len > 35 ? "..." : "", name);

+ 

+ 	return PyString_FromString(repr);

+     }

+ }

+ 

  static struct PyMethodDef BufferMethods[] = {

      /* name,	    function,		calling,    documentation */

      {"append",	    BufferAppend,	1,	    "Append data to Vim buffer" },

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

*** 2497,2502 ****

--- 2681,2729 ----

      { NULL,	    NULL,		0,	    NULL }

  };

+ /* Current items object - Implementation

+  */

+ 

+ static PyInt RangeStart;

+ static PyInt RangeEnd;

+ 

+     static PyObject *

+ CurrentGetattr(PyObject *self UNUSED, char *name)

+ {

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

+ 	return (PyObject *)BufferNew(curbuf);

+     else if (strcmp(name, "window") == 0)

+ 	return (PyObject *)WindowNew(curwin);

+     else if (strcmp(name, "line") == 0)

+ 	return GetBufferLine(curbuf, (PyInt)curwin->w_cursor.lnum);

+     else if (strcmp(name, "range") == 0)

+ 	return RangeNew(curbuf, RangeStart, RangeEnd);

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

+ 	return Py_BuildValue("[ssss]", "buffer", "window", "line", "range");

+     else

+     {

+ 	PyErr_SetString(PyExc_AttributeError, name);

+ 	return NULL;

+     }

+ }

+ 

+     static int

+ CurrentSetattr(PyObject *self UNUSED, char *name, PyObject *value)

+ {

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

+     {

+ 	if (SetBufferLine(curbuf, (PyInt)curwin->w_cursor.lnum, value, NULL) == FAIL)

+ 	    return -1;

+ 

+ 	return 0;

+     }

+     else

+     {

+ 	PyErr_SetString(PyExc_AttributeError, name);

+ 	return -1;

+     }

+ }

+ 

      static void

  set_ref_in_py(const int copyID)

  {

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

*** 2770,2772 ****

--- 2997,3165 ----

  	    return NULL;

      }

  }

+ 

+ typedef struct

+ {

+     PyObject_HEAD

+ } CurrentObject;

+ static PyTypeObject CurrentType;

+ 

+     static void

+ init_structs(void)

+ {

+     vim_memset(&OutputType, 0, sizeof(OutputType));

+     OutputType.tp_name = "vim.message";

+     OutputType.tp_basicsize = sizeof(OutputObject);

+     OutputType.tp_flags = Py_TPFLAGS_DEFAULT;

+     OutputType.tp_doc = "vim message object";

+     OutputType.tp_methods = OutputMethods;

+ #if PY_MAJOR_VERSION >= 3

+     OutputType.tp_getattro = OutputGetattro;

+     OutputType.tp_setattro = OutputSetattro;

+     OutputType.tp_alloc = call_PyType_GenericAlloc;

+     OutputType.tp_new = call_PyType_GenericNew;

+     OutputType.tp_free = call_PyObject_Free;

+ #else

+     OutputType.tp_getattr = OutputGetattr;

+     OutputType.tp_setattr = OutputSetattr;

+ #endif

+ 

+     vim_memset(&BufferType, 0, sizeof(BufferType));

+     BufferType.tp_name = "vim.buffer";

+     BufferType.tp_basicsize = sizeof(BufferType);

+     BufferType.tp_dealloc = BufferDestructor;

+     BufferType.tp_repr = BufferRepr;

+     BufferType.tp_as_sequence = &BufferAsSeq;

+     BufferType.tp_as_mapping = &BufferAsMapping;

+     BufferType.tp_flags = Py_TPFLAGS_DEFAULT;

+     BufferType.tp_doc = "vim buffer object";

+     BufferType.tp_methods = BufferMethods;

+ #if PY_MAJOR_VERSION >= 3

+     BufferType.tp_getattro = BufferGetattro;

+     BufferType.tp_alloc = call_PyType_GenericAlloc;

+     BufferType.tp_new = call_PyType_GenericNew;

+     BufferType.tp_free = call_PyObject_Free;

+ #else

+     BufferType.tp_getattr = BufferGetattr;

+ #endif

+ 

+     vim_memset(&WindowType, 0, sizeof(WindowType));

+     WindowType.tp_name = "vim.window";

+     WindowType.tp_basicsize = sizeof(WindowObject);

+     WindowType.tp_dealloc = WindowDestructor;

+     WindowType.tp_repr = WindowRepr;

+     WindowType.tp_flags = Py_TPFLAGS_DEFAULT;

+     WindowType.tp_doc = "vim Window object";

+     WindowType.tp_methods = WindowMethods;

+ #if PY_MAJOR_VERSION >= 3

+     WindowType.tp_getattro = WindowGetattro;

+     WindowType.tp_setattro = WindowSetattro;

+     WindowType.tp_alloc = call_PyType_GenericAlloc;

+     WindowType.tp_new = call_PyType_GenericNew;

+     WindowType.tp_free = call_PyObject_Free;

+ #else

+     WindowType.tp_getattr = WindowGetattr;

+     WindowType.tp_setattr = WindowSetattr;

+ #endif

+ 

+     vim_memset(&BufListType, 0, sizeof(BufListType));

+     BufListType.tp_name = "vim.bufferlist";

+     BufListType.tp_basicsize = sizeof(BufListObject);

+     BufListType.tp_as_sequence = &BufListAsSeq;

+     BufListType.tp_flags = Py_TPFLAGS_DEFAULT;

+     BufferType.tp_doc = "vim buffer list";

+ 

+     vim_memset(&WinListType, 0, sizeof(WinListType));

+     WinListType.tp_name = "vim.windowlist";

+     WinListType.tp_basicsize = sizeof(WinListType);

+     WinListType.tp_as_sequence = &WinListAsSeq;

+     WinListType.tp_flags = Py_TPFLAGS_DEFAULT;

+     WinListType.tp_doc = "vim window list";

+ 

+     vim_memset(&RangeType, 0, sizeof(RangeType));

+     RangeType.tp_name = "vim.range";

+     RangeType.tp_basicsize = sizeof(RangeObject);

+     RangeType.tp_dealloc = RangeDestructor;

+     RangeType.tp_repr = RangeRepr;

+     RangeType.tp_as_sequence = &RangeAsSeq;

+     RangeType.tp_as_mapping = &RangeAsMapping;

+     RangeType.tp_flags = Py_TPFLAGS_DEFAULT;

+     RangeType.tp_doc = "vim Range object";

+     RangeType.tp_methods = RangeMethods;

+ #if PY_MAJOR_VERSION >= 3

+     RangeType.tp_getattro = RangeGetattro;

+     RangeType.tp_alloc = call_PyType_GenericAlloc;

+     RangeType.tp_new = call_PyType_GenericNew;

+     RangeType.tp_free = call_PyObject_Free;

+ #else

+     RangeType.tp_getattr = RangeGetattr;

+ #endif

+ 

+     vim_memset(&CurrentType, 0, sizeof(CurrentType));

+     CurrentType.tp_name = "vim.currentdata";

+     CurrentType.tp_basicsize = sizeof(CurrentObject);

+     CurrentType.tp_flags = Py_TPFLAGS_DEFAULT;

+     CurrentType.tp_doc = "vim current object";

+ #if PY_MAJOR_VERSION >= 3

+     CurrentType.tp_getattro = CurrentGetattro;

+     CurrentType.tp_setattro = CurrentSetattro;

+ #else

+     CurrentType.tp_getattr = CurrentGetattr;

+     CurrentType.tp_setattr = CurrentSetattr;

+ #endif

+ 

+     vim_memset(&DictionaryType, 0, sizeof(DictionaryType));

+     DictionaryType.tp_name = "vim.dictionary";

+     DictionaryType.tp_basicsize = sizeof(DictionaryObject);

+     DictionaryType.tp_dealloc = DictionaryDestructor;

+     DictionaryType.tp_as_mapping = &DictionaryAsMapping;

+     DictionaryType.tp_flags = Py_TPFLAGS_DEFAULT;

+     DictionaryType.tp_doc = "dictionary pushing modifications to vim structure";

+     DictionaryType.tp_methods = DictionaryMethods;

+ #if PY_MAJOR_VERSION >= 3

+     DictionaryType.tp_getattro = DictionaryGetattro;

+     DictionaryType.tp_setattro = DictionarySetattro;

+ #else

+     DictionaryType.tp_getattr = DictionaryGetattr;

+     DictionaryType.tp_setattr = DictionarySetattr;

+ #endif

+ 

+     vim_memset(&ListType, 0, sizeof(ListType));

+     ListType.tp_name = "vim.list";

+     ListType.tp_dealloc = ListDestructor;

+     ListType.tp_basicsize = sizeof(ListObject);

+     ListType.tp_as_sequence = &ListAsSeq;

+     ListType.tp_as_mapping = &ListAsMapping;

+     ListType.tp_flags = Py_TPFLAGS_DEFAULT;

+     ListType.tp_doc = "list pushing modifications to vim structure";

+     ListType.tp_methods = ListMethods;

+ #if PY_MAJOR_VERSION >= 3

+     ListType.tp_getattro = ListGetattro;

+     ListType.tp_setattro = ListSetattro;

+ #else

+     ListType.tp_getattr = ListGetattr;

+     ListType.tp_setattr = ListSetattr;

+ #endif

+ 

+     vim_memset(&FunctionType, 0, sizeof(FunctionType));

+     FunctionType.tp_name = "vim.list";

+     FunctionType.tp_basicsize = sizeof(FunctionObject);

+     FunctionType.tp_dealloc = FunctionDestructor;

+     FunctionType.tp_call = FunctionCall;

+     FunctionType.tp_flags = Py_TPFLAGS_DEFAULT;

+     FunctionType.tp_doc = "object that calls vim function";

+     FunctionType.tp_methods = FunctionMethods;

+ #if PY_MAJOR_VERSION >= 3

+     FunctionType.tp_getattro = FunctionGetattro;

+ #else

+     FunctionType.tp_getattr = FunctionGetattr;

+ #endif

+ 

+ #if PY_MAJOR_VERSION >= 3

+     vim_memset(&vimmodule, 0, sizeof(vimmodule));

+     vimmodule.m_name = "vim";

+     vimmodule.m_doc = "Vim Python interface\n";

+     vimmodule.m_size = -1;

+     vimmodule.m_methods = VimMethods;

+ #endif

+ }

*** ../vim-7.3.908/src/if_python3.c	2013-04-24 13:04:21.000000000 +0200

--- src/if_python3.c	2013-04-24 13:26:54.000000000 +0200

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

*** 91,96 ****

--- 91,97 ----

  #define PyInt_Check(obj) PyLong_Check(obj)

  #define PyInt_FromLong(i) PyLong_FromLong(i)

  #define PyInt_AsLong(obj) PyLong_AsLong(obj)

+ #define Py_ssize_t_fmt "n"

  #if defined(DYNAMIC_PYTHON3) || defined(PROTO)

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

*** 588,595 ****

  static PyObject *LineToString(const char *);

  static PyObject *BufferDir(PyObject *, PyObject *);

- static PyTypeObject RangeType;

- 

  static int py3initialised = 0;

  #define PYINITIALISED py3initialised

--- 589,594 ----

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

*** 620,636 ****

      if (bytes != NULL) \

  	Py_XDECREF(bytes);

! /*

!  * Include the code shared with if_python.c

!  */

! #include "if_py_both.h"

! 

! #define GET_ATTR_STRING(name, nameobj) \

!     char	*name = ""; \

!     if (PyUnicode_Check(nameobj)) \

! 	name = _PyUnicode_AsString(nameobj)

! 

! #define PY3OBJ_DELETED(obj) (obj->ob_base.ob_refcnt<=0)

      static void

  call_PyObject_Free(void *p)

--- 619,625 ----

      if (bytes != NULL) \

  	Py_XDECREF(bytes);

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

      static void

  call_PyObject_Free(void *p)

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

*** 654,666 ****

      return PyType_GenericAlloc(type,nitems);

  }

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

   * Internal function prototypes.

   */

- static Py_ssize_t RangeStart;

- static Py_ssize_t RangeEnd;

- 

  static PyObject *globals;

  static int PythonIO_Init(void);

--- 643,680 ----

      return PyType_GenericAlloc(type,nitems);

  }

+ static PyObject *OutputGetattro(PyObject *, PyObject *);

+ static int OutputSetattro(PyObject *, PyObject *, PyObject *);

+ static PyObject *BufferGetattro(PyObject *, PyObject *);

+ static PyObject *WindowGetattro(PyObject *, PyObject *);

+ static int WindowSetattro(PyObject *, PyObject *, PyObject *);

+ static PyObject *RangeGetattro(PyObject *, PyObject *);

+ static PyObject *CurrentGetattro(PyObject *, PyObject *);

+ static int CurrentSetattro(PyObject *, PyObject *, PyObject *);

+ static PyObject *DictionaryGetattro(PyObject *, PyObject *);

+ static int DictionarySetattro(PyObject *, PyObject *, PyObject *);

+ static PyObject *ListGetattro(PyObject *, PyObject *);

+ static int ListSetattro(PyObject *, PyObject *, PyObject *);

+ static PyObject *FunctionGetattro(PyObject *, PyObject *);

+ 

+ static struct PyModuleDef vimmodule;

+ 

+ /*

+  * Include the code shared with if_python.c

+  */

+ #include "if_py_both.h"

+ 

+ #define GET_ATTR_STRING(name, nameobj) \

+     char	*name = ""; \

+     if (PyUnicode_Check(nameobj)) \

+ 	name = _PyUnicode_AsString(nameobj)

+ 

+ #define PY3OBJ_DELETED(obj) (obj->ob_base.ob_refcnt<=0)

+ 

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

   * Internal function prototypes.

   */

  static PyObject *globals;

  static int PythonIO_Init(void);

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

*** 1046,1052 ****

      0,					    /* sq_inplace_repeat */

  };

! PyMappingMethods BufferAsMapping = {

      /* mp_length	*/ (lenfunc)BufferLength,

      /* mp_subscript     */ (binaryfunc)BufferSubscript,

      /* mp_ass_subscript */ (objobjargproc)BufferAsSubscript,

--- 1060,1066 ----

      0,					    /* sq_inplace_repeat */

  };

! static PyMappingMethods BufferAsMapping = {

      /* mp_length	*/ (lenfunc)BufferLength,

      /* mp_subscript     */ (binaryfunc)BufferSubscript,

      /* mp_ass_subscript */ (objobjargproc)BufferAsSubscript,

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

*** 1056,1063 ****

  /* Buffer object - Definitions

   */

- static PyTypeObject BufferType;

- 

      static PyObject *

  BufferNew(buf_T *buf)

  {

--- 1070,1075 ----

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

*** 1094,1124 ****

      return (PyObject *)(self);

  }

-     static void

- BufferDestructor(PyObject *self)

- {

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

- 

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

- 	this->buf->b_python3_ref = NULL;

- 

-     Py_TYPE(self)->tp_free((PyObject*)self);

- }

- 

      static PyObject *

  BufferGetattro(PyObject *self, PyObject*nameobj)

  {

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

      GET_ATTR_STRING(name, nameobj);

!     if (CheckBuffer(this))

  	return NULL;

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

! 	return Py_BuildValue("s", this->buf->b_ffname);

!     else if (strcmp(name, "number") == 0)

! 	return Py_BuildValue("n", this->buf->b_fnum);

      else

  	return PyObject_GenericGetAttr(self, nameobj);

  }

--- 1106,1124 ----

      return (PyObject *)(self);

  }

      static PyObject *

  BufferGetattro(PyObject *self, PyObject*nameobj)

  {

!     PyObject *r;

      GET_ATTR_STRING(name, nameobj);

!     if (CheckBuffer((BufferObject *)(self)))

  	return NULL;

!     r = BufferAttr((BufferObject *)(self), name);

!     if (r || PyErr_Occurred())

! 	return r;

      else

  	return PyObject_GenericGetAttr(self, nameobj);

  }

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

*** 1130,1164 ****

  						   "append", "mark", "range");

  }

-     static PyObject *

- BufferRepr(PyObject *self)

- {

-     static char repr[100];

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

- 

-     if (this->buf == INVALID_BUFFER_VALUE)

-     {

- 	vim_snprintf(repr, 100, _("<buffer object (deleted) at %p>"), (self));

- 	return PyUnicode_FromString(repr);

-     }

-     else

-     {

- 	char *name = (char *)this->buf->b_fname;

- 	Py_ssize_t len;

-