To: vim_dev@googlegroups.com

Subject: Patch 7.3.1061

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

Problem:    Python: Dictionary is not standard.

Solution:   Python patch 20: Add standard methods and fields. (ZyX)

Files:	    runtime/doc/if_pyth.txt, src/eval.c, src/if_py_both.h,

	    src/if_python3.c, src/if_python.c, src/proto/eval.pro,

	    src/testdir/test86.in, src/testdir/test86.ok,

	    src/testdir/test87.in, src/testdir/test87.ok

*** ../vim-7.3.1060/runtime/doc/if_pyth.txt	2013-05-29 22:02:18.000000000 +0200

--- runtime/doc/if_pyth.txt	2013-05-30 12:47:48.000000000 +0200

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

*** 12,20 ****

  4. Range objects				|python-range|

  5. Window objects				|python-window|

  6. Tab page objects				|python-tabpage|

! 7. pyeval(), py3eval() Vim functions		|python-pyeval|

! 8. Dynamic loading				|python-dynamic|

! 9. Python 3					|python3|

  {Vi does not have any of these commands}

--- 12,21 ----

  4. Range objects				|python-range|

  5. Window objects				|python-window|

  6. Tab page objects				|python-tabpage|

! 7. vim.bindeval objects				|python-bindeval-objects|

! 8. pyeval(), py3eval() Vim functions		|python-pyeval|

! 9. Dynamic loading				|python-dynamic|

! 10. Python 3					|python3|

  {Vi does not have any of these commands}

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

*** 171,217 ****

  	'eval_expr', 'kind': 'f', 'filename': './src/eval.c'}]

  vim.bindeval(str)					*python-bindeval*

! 	Like |python-eval|, but

! 	1. if expression evaluates to |List| or |Dictionary| it is returned as 

! 	   vimlist or vimdictionary python type that are connected to original 

! 	   list or dictionary. Thus modifications to these objects imply 

! 	   modifications of the original.

! 

! 	   Additionally, vim.List and vim.Dictionary type have read-write 

! 	   `.locked` attribute that returns

! 	     Value           Meaning ~

! 	     zero            Variable is not locked

! 	     vim.VAR_LOCKED  Variable is locked, but can be unlocked

! 	     vim.VAR_FIXED   Variable is locked and can't be unlocked

! 	   integer constants. If variable is not fixed, you can do 

! 	   `var.locked=True` to lock it and `var.locked=False` to unlock. 

! 	   There is no recursive locking like |:lockvar|! does. There is also 

! 	   no way to lock a specific key or check whether it is locked (in any 

! 	   case these locks are ignored by anything except |:let|: |extend()| 

! 	   does not care, neither does python interface).

! 

! 	   vim.Dictionary type also supports `.scope` attribute which is one 

! 	   of

! 	     Value              Meaning ~

! 	     zero               Dictionary is not a scope one

! 	     vim.VAR_DEF_SCOPE  Function-local or global scope dictionary

! 	     vim.VAR_SCOPE      Other scope dictionary

! 

! 	2. if expression evaluates to a function reference, then it returns 

! 	   callable vim.Function object. Use self keyword argument to assign 

! 	   |self| object for dictionary functions.

! 

! 	Note: this function has the same behavior as |lua-eval| (except that 

! 	      lua does not support running vim functions), |python-eval| is 

! 	      kept for backwards compatibility in order not to make scripts 

! 	      relying on outputs of vim.eval() being a copy of original or 

! 	      vim.eval("1") returning a string.

! 

! 	You can use "List", "Dictionary" and "Function" vim module attributes 

! 	to test whether object has given type. These types are currently not 

! 	subclassable, neither they contain constructors, so you can use them 

! 	only for checks like `isinstance(obj, vim.List)`.

! 

  Error object of the "vim" module

--- 172,180 ----

  	'eval_expr', 'kind': 'f', 'filename': './src/eval.c'}]

  vim.bindeval(str)					*python-bindeval*

! 	Like |python-eval|, but returns special objects described in 

! 	|python-bindeval-objects|. These python objects let you modify (|List| 

! 	or |Dictionary|) or call (|Funcref|) vim objecs.

  Error object of the "vim" module

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

*** 497,509 ****

  TabPage object type is available using "TabPage" attribute of vim module.

  ==============================================================================

! 7. pyeval() and py3eval() Vim functions			*python-pyeval*

  To facilitate bi-directional interface, you can use |pyeval()| and |py3eval()| 

  functions to evaluate Python expressions and pass their values to VimL.

  ==============================================================================

! 8. Dynamic loading					*python-dynamic*

  On MS-Windows the Python library can be loaded dynamically.  The |:version|

  output then includes |+python/dyn|.

--- 460,549 ----

  TabPage object type is available using "TabPage" attribute of vim module.

  ==============================================================================

! 7. vim.bindeval objects				*python-bindeval-objects*

! 

! vim.Dictionary object				*python-Dictionary*

!     Dictionary-like object providing access to vim |Dictionary| type.

!     Attributes:

!         Attribute  Description ~

!         locked     One of                       *python-.locked*

!                     Value           Description ~

!                     zero            Variable is not locked

!                     vim.VAR_LOCKED  Variable is locked, but can be unlocked

!                     vim.VAR_FIXED   Variable is locked and can't be unlocked

!                    Read-write. You can unlock locked variable by assigning 

!                    `True` or `False` to this attribute. No recursive locking 

!                    is supported.

!         scope      One of

!                     Value              Description ~

!                     zero               Dictionary is not a scope one

!                     vim.VAR_DEF_SCOPE  |g:| or |l:| dictionary

!                     vim.VAR_SCOPE      Other scope dictionary,

!                                        see |internal-variables|

!     Methods:

!         Method      Description ~

!         keys()      Returns a list with dictionary keys.

!         values()    Returns a list with dictionary values.

!         items()     Returns a list of 2-tuples with dictionary contents.

!         update(iterable)

!         update(dictionary)

!         update(**kwargs)

!                     Adds keys to dictionary.

!     Examples: >

!         py d = vim.bindeval('{}')

!         d['a'] = 'b'				# Item assignment

!         print d['a']				# getting item

!         d.update({'c': 'd'})			# .update(dictionary)

!         d.update(e='f')				# .update(**kwargs)

!         d.update((('g', 'h'), ('i', 'j')))	# .update(iterable)

!         for key in d.keys():			# .keys()

!         for val in d.values():			# .values()

!         for key, val in d.items():		# .items()

!         print isinstance(d, vim.Dictionary)	# True

!         for key in d:				# Iteration over keys

! <

!     Note: when iterating over keys you should not modify dictionary.

! 

! vim.List object					*python-List*

!     Sequence-like object providing access to vim |List| type.

!     Supports `.locked` attribute, see |python-.locked|. Also supports the 

!     following methods:

!         Method          Description ~

!         extend(item)    Add items to the list.

!     Examples: >

!         l = vim.bindeval('[]')

!         l.extend(['abc', 'def'])	# .extend() method

!         print l[1:]			# slicing

!         l[:0] = ['ghi', 'jkl']		# slice assignment

!         print l[0]			# getting item

!         l[0] = 'mno'			# assignment

!         for i in l:			# iteration

!         print isinstance(l, vim.List)	# True

! 

! vim.Function object				*python-Function*

!     Function-like object, acting like vim |Funcref| object. Supports `.name` 

!     attribute and is callable. Accepts special keyword argument `self`, see 

!     |Dictionary-function|.

!     Examples: >

!         f = vim.bindeval('function("tr")')

!         print f('abc', 'a', 'b')		# Calls tr('abc', 'a', 'b')

!         vim.command('''

!             function DictFun() dict

!                 return self

!             endfunction

!         ''')

!         f = vim.bindeval('function("DictFun")')

!         print f(self={})			# Like call('DictFun', [], {})

!         print isinstance(f, vim.Function)	# True

! 

! ==============================================================================

! 8. pyeval() and py3eval() Vim functions			*python-pyeval*

  To facilitate bi-directional interface, you can use |pyeval()| and |py3eval()| 

  functions to evaluate Python expressions and pass their values to VimL.

  ==============================================================================

! 9. Dynamic loading					*python-dynamic*

  On MS-Windows the Python library can be loaded dynamically.  The |:version|

  output then includes |+python/dyn|.

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

*** 520,526 ****

  sure edit "gvim.exe" and search for "python\d*.dll\c".

  ==============================================================================

! 9. Python 3						*python3*

  							*:py3* *:python3*

  The `:py3` and `:python3` commands work similar to `:python`.  A simple check

--- 560,566 ----

  sure edit "gvim.exe" and search for "python\d*.dll\c".

  ==============================================================================

! 10. Python 3						*python3*

  							*:py3* *:python3*

  The `:py3` and `:python3` commands work similar to `:python`.  A simple check

*** ../vim-7.3.1060/src/eval.c	2013-05-30 12:35:48.000000000 +0200

--- src/eval.c	2013-05-30 12:52:11.000000000 +0200

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

*** 10157,10162 ****

--- 10157,10218 ----

  }

  /*

+  * Go over all entries in "d2" and add them to "d1".

+  * When "action" is "error" then a duplicate key is an error.

+  * When "action" is "force" then a duplicate key is overwritten.

+  * Otherwise duplicate keys are ignored ("action" is "keep").

+  */

+     void

+ dict_extend(d1, d2, action)

+     dict_T	*d1;

+     dict_T	*d2;

+     char_u	*action;

+ {

+     dictitem_T	*di1;

+     hashitem_T	*hi2;

+     int		todo;

+ 

+     todo = (int)d2->dv_hashtab.ht_used;

+     for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2)

+     {

+ 	if (!HASHITEM_EMPTY(hi2))

+ 	{

+ 	    --todo;

+ 	    di1 = dict_find(d1, hi2->hi_key, -1);

+ 	    if (d1->dv_scope != 0)

+ 	    {

+ 		/* Disallow replacing a builtin function in l: and g:.

+ 		 * Check the key to be valid when adding to any

+ 		 * scope. */

+ 		if (d1->dv_scope == VAR_DEF_SCOPE

+ 			&& HI2DI(hi2)->di_tv.v_type == VAR_FUNC

+ 			&& var_check_func_name(hi2->hi_key,

+ 							 di1 == NULL))

+ 		    break;

+ 		if (!valid_varname(hi2->hi_key))

+ 		    break;

+ 	    }

+ 	    if (di1 == NULL)

+ 	    {

+ 		di1 = dictitem_copy(HI2DI(hi2));

+ 		if (di1 != NULL && dict_add(d1, di1) == FAIL)

+ 		    dictitem_free(di1);

+ 	    }

+ 	    else if (*action == 'e')

+ 	    {

+ 		EMSG2(_("E737: Key already exists: %s"), hi2->hi_key);

+ 		break;

+ 	    }

+ 	    else if (*action == 'f' && HI2DI(hi2) != di1)

+ 	    {

+ 		clear_tv(&di1->di_tv);

+ 		copy_tv(&HI2DI(hi2)->di_tv, &di1->di_tv);

+ 	    }

+ 	}

+     }

+ }

+ 

+ /*

   * "extend(list, list [, idx])" function

   * "extend(dict, dict [, action])" function

   */

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

*** 10206,10217 ****

      }

      else if (argvars[0].v_type == VAR_DICT && argvars[1].v_type == VAR_DICT)

      {

! 	dict_T		*d1, *d2;

! 	dictitem_T	*di1;

! 	char_u		*action;

! 	int		i;

! 	hashitem_T	*hi2;

! 	int		todo;

  	d1 = argvars[0].vval.v_dict;

  	d2 = argvars[1].vval.v_dict;

--- 10262,10270 ----

      }

      else if (argvars[0].v_type == VAR_DICT && argvars[1].v_type == VAR_DICT)

      {

! 	dict_T	*d1, *d2;

! 	char_u	*action;

! 	int	i;

  	d1 = argvars[0].vval.v_dict;

  	d2 = argvars[1].vval.v_dict;

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

*** 10238,10283 ****

  	    else

  		action = (char_u *)"force";

! 	    /* Go over all entries in the second dict and add them to the

! 	     * first dict. */

! 	    todo = (int)d2->dv_hashtab.ht_used;

! 	    for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2)

! 	    {

! 		if (!HASHITEM_EMPTY(hi2))

! 		{

! 		    --todo;

! 		    di1 = dict_find(d1, hi2->hi_key, -1);

! 		    if (d1->dv_scope != 0)

! 		    {

! 			/* Disallow replacing a builtin function in l: and g:.

! 			 * Check the key to be valid when adding to any

! 			 * scope. */

! 		        if (d1->dv_scope == VAR_DEF_SCOPE

! 				&& HI2DI(hi2)->di_tv.v_type == VAR_FUNC

! 				&& var_check_func_name(hi2->hi_key,

! 								 di1 == NULL))

! 			    break;

! 			if (!valid_varname(hi2->hi_key))

! 			    break;

! 		    }

! 		    if (di1 == NULL)

! 		    {

! 			di1 = dictitem_copy(HI2DI(hi2));

! 			if (di1 != NULL && dict_add(d1, di1) == FAIL)

! 			    dictitem_free(di1);

! 		    }

! 		    else if (*action == 'e')

! 		    {

! 			EMSG2(_("E737: Key already exists: %s"), hi2->hi_key);

! 			break;

! 		    }

! 		    else if (*action == 'f' && HI2DI(hi2) != di1)

! 		    {

! 			clear_tv(&di1->di_tv);

! 			copy_tv(&HI2DI(hi2)->di_tv, &di1->di_tv);

! 		    }

! 		}

! 	    }

  	    copy_tv(&argvars[0], rettv);

  	}

--- 10291,10297 ----

  	    else

  		action = (char_u *)"force";

! 	    dict_extend(d1, d2, action);

  	    copy_tv(&argvars[0], rettv);

  	}

*** ../vim-7.3.1060/src/if_py_both.h	2013-05-30 12:43:50.000000000 +0200

--- src/if_py_both.h	2013-05-30 12:52:42.000000000 +0200

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

*** 31,37 ****

  #define INVALID_TABPAGE_VALUE ((tabpage_T *)(-1))

  #define DICTKEY_DECL \

!     PyObject	*dictkey_todecref;

  #define DICTKEY_CHECK_EMPTY(err) \

      if (*key == NUL) \

      { \

--- 31,37 ----

  #define INVALID_TABPAGE_VALUE ((tabpage_T *)(-1))

  #define DICTKEY_DECL \

!     PyObject	*dictkey_todecref = NULL;

  #define DICTKEY_CHECK_EMPTY(err) \

      if (*key == NUL) \

      { \

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

*** 63,68 ****

--- 63,69 ----

  static int ConvertFromPyObject(PyObject *, typval_T *);

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

+ static int ConvertFromPyMapping(PyObject *, typval_T *);

  static PyObject *WindowNew(win_T *, tabpage_T *);

  static PyObject *BufferNew (buf_T *);

  static PyObject *LineToString(const char *);

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

*** 877,888 ****

      pylinkedlist_T	ref;

  } DictionaryObject;

      static PyObject *

! DictionaryNew(dict_T *dict)

  {

      DictionaryObject	*self;

!     self = PyObject_NEW(DictionaryObject, &DictionaryType);

      if (self == NULL)

  	return NULL;

      self->dict = dict;

--- 878,893 ----

      pylinkedlist_T	ref;

  } DictionaryObject;

+ static PyObject *DictionaryUpdate(DictionaryObject *, PyObject *, PyObject *);

+ 

+ #define NEW_DICTIONARY(dict) DictionaryNew(&DictionaryType, dict)

+ 

      static PyObject *

! DictionaryNew(PyTypeObject *subtype, dict_T *dict)

  {

      DictionaryObject	*self;

!     self = (DictionaryObject *) subtype->tp_alloc(subtype, 0);

      if (self == NULL)

  	return NULL;

      self->dict = dict;

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

*** 893,898 ****

--- 898,946 ----

      return (PyObject *)(self);

  }

+     static dict_T *

+ py_dict_alloc()

+ {

+     dict_T	*r;

+ 

+     if (!(r = dict_alloc()))

+     {

+ 	PyErr_NoMemory();

+ 	return NULL;

+     }

+     ++r->dv_refcount;

+ 

+     return r;

+ }

+ 

+     static PyObject *

+ DictionaryConstructor(PyTypeObject *subtype, PyObject *args, PyObject *kwargs)

+ {

+     DictionaryObject	*self;

+     dict_T	*dict;

+ 

+     if (!(dict = py_dict_alloc()))

+ 	return NULL;

+ 

+     self = (DictionaryObject *) DictionaryNew(subtype, dict);

+ 

+     --dict->dv_refcount;

+ 

+     if (kwargs || PyTuple_Size(args))

+     {

+ 	PyObject	*tmp;

+ 	if (!(tmp = DictionaryUpdate(self, args, kwargs)))

+ 	{

+ 	    Py_DECREF(self);

+ 	    return NULL;

+ 	}

+ 

+ 	Py_DECREF(tmp);

+     }

+ 

+     return (PyObject *)(self);

+ }

+ 

      static void

  DictionaryDestructor(DictionaryObject *self)

  {

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

*** 918,924 ****

  {

      if (val == NULL)

      {

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

  	return -1;

      }

--- 966,973 ----

  {

      if (val == NULL)

      {

! 	PyErr_SetString(PyExc_AttributeError,

! 		_("cannot delete vim.Dictionary attributes"));

  	return -1;

      }

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

*** 926,932 ****

      {

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

  	{

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

  	    return -1;

  	}

  	else

--- 975,981 ----

      {

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

  	{

! 	    PyErr_SetString(PyExc_TypeError, _("cannot modify fixed dictionary"));

  	    return -1;

  	}

  	else

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

*** 943,949 ****

      }

      else

      {

! 	PyErr_SetString(PyExc_AttributeError, _("Cannot set this attribute"));

  	return -1;

      }

  }

--- 992,998 ----

      }

      else

      {

! 	PyErr_SetString(PyExc_AttributeError, _("cannot set this attribute"));

  	return -1;

      }

  }

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

*** 954,979 ****

      return ((PyInt) (self->dict->dv_hashtab.ht_used));

  }

      static PyObject *

! DictionaryItem(DictionaryObject *self, PyObject *keyObject)

  {

      char_u	*key;

      dictitem_T	*di;

      DICTKEY_DECL

      DICTKEY_GET(NULL, 0)

!     di = dict_find(self->dict, key, -1);

      DICTKEY_UNREF

!     if (di == NULL)

      {

! 	PyErr_SetObject(PyExc_KeyError, keyObject);

  	return NULL;

      }

!     return ConvertToPyObject(&di->di_tv);

  }

      static PyInt

--- 1003,1172 ----

      return ((PyInt) (self->dict->dv_hashtab.ht_used));

  }

+ #define DICT_FLAG_HAS_DEFAULT	0x01

+ #define DICT_FLAG_POP		0x02

+ #define DICT_FLAG_NONE_DEFAULT	0x04

+ #define DICT_FLAG_RETURN_BOOL	0x08 /* Incompatible with DICT_FLAG_POP */

+ #define DICT_FLAG_RETURN_PAIR	0x10

+ 

      static PyObject *

! _DictionaryItem(DictionaryObject *self, PyObject *args, int flags)

  {

+     PyObject	*keyObject;

+     PyObject	*defObject = ((flags & DICT_FLAG_NONE_DEFAULT)? Py_None : NULL);

+     PyObject	*r;

      char_u	*key;

      dictitem_T	*di;

+     dict_T	*dict = self->dict;

+     hashitem_T	*hi;

+ 

      DICTKEY_DECL

+     if (flags & DICT_FLAG_HAS_DEFAULT)

+     {

+ 	if (!PyArg_ParseTuple(args, "O|O", &keyObject, &defObject))

+ 	    return NULL;

+     }

+     else

+ 	keyObject = args;

+ 

+     if (flags & DICT_FLAG_RETURN_BOOL)

+ 	defObject = Py_False;

+ 

      DICTKEY_GET(NULL, 0)

!     hi = hash_find(&dict->dv_hashtab, key);

      DICTKEY_UNREF

!     if (HASHITEM_EMPTY(hi))

      {

! 	if (defObject)

! 	{

! 	    Py_INCREF(defObject);

! 	    return defObject;

! 	}

! 	else

! 	{

! 	    PyErr_SetObject(PyExc_KeyError, keyObject);

! 	    return NULL;

! 	}

!     }

!     else if (flags & DICT_FLAG_RETURN_BOOL)

!     {

! 	Py_INCREF(Py_True);

! 	return Py_True;

!     }

! 

!     di = dict_lookup(hi);

! 

!     if (!(r = ConvertToPyObject(&di->di_tv)))

  	return NULL;

+ 

+     if (flags & DICT_FLAG_POP)

+     {

+ 	if (dict->dv_lock)

+ 	{

+ 	    PyErr_SetVim(_("dict is locked"));

+ 	    Py_DECREF(r);

+ 	    return NULL;

+ 	}

+ 

+ 	hash_remove(&dict->dv_hashtab, hi);

+ 	dictitem_free(di);

      }

!     if (flags & DICT_FLAG_RETURN_PAIR)

!     {

! 	PyObject	*tmp = r;

! 

! 	if (!(r = Py_BuildValue("(" Py_bytes_fmt "O)", hi->hi_key, tmp)))

! 	{

! 	    Py_DECREF(tmp);

! 	    return NULL;

! 	}

!     }

! 

!     return r;

! }

! 

!     static PyObject *

! DictionaryItem(DictionaryObject *self, PyObject *keyObject)

! {

!     return _DictionaryItem(self, keyObject, 0);

! }

! 

!     static int

! DictionaryContains(DictionaryObject *self, PyObject *keyObject)

! {

!     PyObject	*rObj = _DictionaryItem(self, keyObject, DICT_FLAG_RETURN_BOOL);

!     int		r;

! 

!     r = (rObj == Py_True);

! 

!     Py_DECREF(Py_True);

! 

!     return r;

! }

! 

! typedef struct

! {

!     hashitem_T	*ht_array;

!     long_u	ht_used;

!     hashtab_T	*ht;

!     hashitem_T	*hi;

!     int		todo;

! } dictiterinfo_T;

! 

!     static PyObject *

! DictionaryIterNext(dictiterinfo_T **dii)

! {

!     PyObject	*r;

! 

!     if (!(*dii)->todo)

! 	return NULL;

! 

!     if ((*dii)->ht->ht_array != (*dii)->ht_array ||

! 	    (*dii)->ht->ht_used != (*dii)->ht_used)

!     {

! 	PyErr_SetString(PyExc_RuntimeError,

! 		_("hashtab changed during iteration"));

! 	return NULL;

!     }

! 

!     while (((*dii)->todo) && HASHITEM_EMPTY((*dii)->hi))

! 	++((*dii)->hi);

! 

!     --((*dii)->todo);

! 

!     if (!(r = PyBytes_FromString((char *) (*dii)->hi->hi_key)))

! 	return NULL;

! 

!     return r;

! }

! 

!     static PyObject *

! DictionaryIter(DictionaryObject *self)

! {

!     dictiterinfo_T	*dii;

!     hashtab_T		*ht;

! 

!     if (!(dii = PyMem_New(dictiterinfo_T, 1)))

!     {

! 	PyErr_NoMemory();

! 	return NULL;

!     }

! 

!     ht = &self->dict->dv_hashtab;

!     dii->ht_array = ht->ht_array;

!     dii->ht_used = ht->ht_used;

!     dii->ht = ht;

!     dii->hi = dii->ht_array;

!     dii->todo = dii->ht_used;

! 

!     return IterNew(dii,

! 	    (destructorfun) PyMem_Free, (nextfun) DictionaryIterNext,

! 	    NULL, NULL);

  }

      static PyInt

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

*** 1016,1033 ****

      if (di == NULL)

      {

! 	di = dictitem_alloc(key);

! 	if (di == NULL)

  	{

  	    PyErr_NoMemory();

  	    return -1;

  	}

  	di->di_tv.v_lock = 0;

  	if (dict_add(dict, di) == FAIL)

  	{

  	    DICTKEY_UNREF

  	    vim_free(di);

  	    PyErr_SetVim(_("failed to add key to dictionary"));

  	    return -1;

  	}

--- 1209,1227 ----

      if (di == NULL)

      {

! 	if (!(di = dictitem_alloc(key)))

  	{

  	    PyErr_NoMemory();

  	    return -1;

  	}

  	di->di_tv.v_lock = 0;

+ 	di->di_tv.v_type = VAR_UNKNOWN;

  	if (dict_add(dict, di) == FAIL)

  	{

  	    DICTKEY_UNREF

  	    vim_free(di);

+ 	    dictitem_free(di);

  	    PyErr_SetVim(_("failed to add key to dictionary"));

  	    return -1;

  	}

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

*** 1042,1062 ****

      return 0;

  }

      static PyObject *

! DictionaryListKeys(DictionaryObject *self)

  {

      dict_T	*dict = self->dict;

      long_u	todo = dict->dv_hashtab.ht_used;

      Py_ssize_t	i = 0;

      PyObject	*r;

      hashitem_T	*hi;

      r = PyList_New(todo);

      for (hi = dict->dv_hashtab.ht_array; todo > 0; ++hi)

      {

  	if (!HASHITEM_EMPTY(hi))

  	{

! 	    PyList_SetItem(r, i, PyBytes_FromString((char *)(hi->hi_key)));

  	    --todo;

  	    ++i;

  	}

--- 1236,1269 ----

      return 0;

  }

+ typedef PyObject *(*hi_to_py)(hashitem_T *);

+ 

      static PyObject *

! DictionaryListObjects(DictionaryObject *self, hi_to_py hiconvert)

  {

      dict_T	*dict = self->dict;

      long_u	todo = dict->dv_hashtab.ht_used;

      Py_ssize_t	i = 0;

      PyObject	*r;

      hashitem_T	*hi;

+     PyObject	*newObj;

      r = PyList_New(todo);

      for (hi = dict->dv_hashtab.ht_array; todo > 0; ++hi)

      {

  	if (!HASHITEM_EMPTY(hi))

  	{

! 	    if (!(newObj = hiconvert(hi)))

! 	    {

! 		Py_DECREF(r);

! 		return NULL;

! 	    }

! 	    if (PyList_SetItem(r, i, newObj))

! 	    {

! 		Py_DECREF(r);

! 		Py_DECREF(newObj);

! 		return NULL;

! 	    }

  	    --todo;

  	    ++i;

  	}

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

*** 1064,1069 ****

--- 1271,1505 ----

      return r;

  }

+     static PyObject *

+ dict_key(hashitem_T *hi)

+ {

+     return PyBytes_FromString((char *)(hi->hi_key));

+ }

+ 

+     static PyObject *

+ DictionaryListKeys(DictionaryObject *self)

+ {

+     return DictionaryListObjects(self, dict_key);

+ }

+ 

+     static PyObject *

+ dict_val(hashitem_T *hi)

+ {

+     dictitem_T	*di;

+ 

+     di = dict_lookup(hi);

+     return ConvertToPyObject(&di->di_tv);

+ }

+ 

+     static PyObject *

+ DictionaryListValues(DictionaryObject *self)

+ {

+     return DictionaryListObjects(self, dict_val);

+ }

+ 

+     static PyObject *

+ dict_item(hashitem_T *hi)

+ {

+     PyObject	*keyObject;

+     PyObject	*valObject;

+     PyObject	*r;

+ 

+     if (!(keyObject = dict_key(hi)))

+ 	return NULL;

+ 

+     if (!(valObject = dict_val(hi)))

+     {

+ 	Py_DECREF(keyObject);

+ 	return NULL;