ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 765 insertions, 711 deletions

diff --git a/source/blender/python/bmesh/bmesh_py_ops_call.c b/source/blender/python/bmesh/bmesh_py_ops_call.c
index b9d506c4c41..401dded5188 100644
--- a/source/blender/python/bmesh/bmesh_py_ops_call.c
+++ b/source/blender/python/bmesh/bmesh_py_ops_call.c
@@ -33,7 +33,7 @@
 
 #include "bmesh.h"
 
-#include "bmesh_py_ops_call.h"  /* own include */
+#include "bmesh_py_ops_call.h" /* own include */
 
 #include "bmesh_py_types.h"
 
@@ -44,18 +44,16 @@ BLI_STATIC_ASSERT(sizeof(PyC_FlagSet) == sizeof(BMO_FlagSet), "size mismatch");
 
 static int bpy_bm_op_as_py_error(BMesh *bm)
 {
-	if (BMO_error_occurred(bm)) {
-		/* note: we could have multiple errors */
-		const char *errmsg;
-		if (BMO_error_get(bm, &errmsg, NULL)) {
-			PyErr_Format(PyExc_RuntimeError,
-			             "bmesh operator: %.200s",
-			             errmsg);
-			BMO_error_clear(bm);
-			return -1;
-		}
-	}
-	return 0;
+  if (BMO_error_occurred(bm)) {
+    /* note: we could have multiple errors */
+    const char *errmsg;
+    if (BMO_error_get(bm, &errmsg, NULL)) {
+      PyErr_Format(PyExc_RuntimeError, "bmesh operator: %.200s", errmsg);
+      BMO_error_clear(bm);
+      return -1;
+    }
+  }
+  return 0;
 }
 
 /**
@@ -66,34 +64,41 @@ static int bpy_bm_op_as_py_error(BMesh *bm)
  * \param htype: Test \a value matches this type.
  * \param descr: Description text.
  */
-static int bpy_slot_from_py_elem_check(
-        BPy_BMElem *value, BMesh *bm, const char htype,
-        /* for error messages */
-        const char *opname, const char *slot_name, const char *descr)
+static int bpy_slot_from_py_elem_check(BPy_BMElem *value,
+                                       BMesh *bm,
+                                       const char htype,
+                                       /* for error messages */
+                                       const char *opname,
+                                       const char *slot_name,
+                                       const char *descr)
 {
-	if (!BPy_BMElem_Check(value) ||
-	    !(value->ele->head.htype & htype))
-	{
-		PyErr_Format(PyExc_TypeError,
-		             "%.200s: keyword \"%.200s\" %.200s, expected a %.200s not *.200s",
-		             opname, slot_name, descr,
-		             BPy_BMElem_StringFromHType(htype),
-		             Py_TYPE(value)->tp_name);
-		return -1;
-	}
-	else if (value->bm == NULL) {
-		PyErr_Format(PyExc_TypeError,
-		             "%.200s: keyword \"%.200s\" %.200s invalidated element",
-		             opname, slot_name, descr);
-		return -1;
-	}
-	else if (value->bm != bm) {  /* we may want to make this check optional by setting 'bm' to NULL */
-		PyErr_Format(PyExc_TypeError,
-		             "%.200s: keyword \"%.200s\" %.200s invalidated element",
-		             opname, slot_name, descr);
-		return -1;
-	}
-	return 0;
+  if (!BPy_BMElem_Check(value) || !(value->ele->head.htype & htype)) {
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s: keyword \"%.200s\" %.200s, expected a %.200s not *.200s",
+                 opname,
+                 slot_name,
+                 descr,
+                 BPy_BMElem_StringFromHType(htype),
+                 Py_TYPE(value)->tp_name);
+    return -1;
+  }
+  else if (value->bm == NULL) {
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s: keyword \"%.200s\" %.200s invalidated element",
+                 opname,
+                 slot_name,
+                 descr);
+    return -1;
+  }
+  else if (value->bm != bm) { /* we may want to make this check optional by setting 'bm' to NULL */
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s: keyword \"%.200s\" %.200s invalidated element",
+                 opname,
+                 slot_name,
+                 descr);
+    return -1;
+  }
+  return 0;
 }
 
 /**
@@ -105,434 +110,493 @@ static int bpy_slot_from_py_elem_check(
  * \param htype_bmo: The type(s) supported by the target slot.
  * \param descr: Description text.
  */
-static int bpy_slot_from_py_elemseq_check(
-        BPy_BMGeneric *value, BMesh *bm,
-        const char htype_py, const char htype_bmo,
-        /* for error messages */
-        const char *opname, const char *slot_name, const char *descr)
+static int bpy_slot_from_py_elemseq_check(BPy_BMGeneric *value,
+                                          BMesh *bm,
+                                          const char htype_py,
+                                          const char htype_bmo,
+                                          /* for error messages */
+                                          const char *opname,
+                                          const char *slot_name,
+                                          const char *descr)
 {
-	if (value->bm == NULL) {
-		PyErr_Format(PyExc_TypeError,
-		             "%.200s: keyword \"%.200s\" %.200s, invalidated sequence",
-		             opname, slot_name, descr);
-		return -1;
-	}
-	else if (value->bm != bm) {  /* we may want to make this check optional by setting 'bm' to NULL */
-		PyErr_Format(PyExc_TypeError,
-		             "%.200s: keyword \"%.200s\" %.200s, invalidated sequence",
-		             opname, slot_name, descr);
-		return -1;
-	}
-	else if ((htype_py & htype_bmo) == 0) {
-		char str_bmo[32];
-		char str_py[32];
-		PyErr_Format(PyExc_TypeError,
-		             "%.200s: keyword \"%.200s\" %.200s, expected "
-		             "a sequence of %.200s not %.200s",
-		             opname, slot_name, descr,
-		             BPy_BMElem_StringFromHType_ex(htype_bmo, str_bmo),
-		             BPy_BMElem_StringFromHType_ex(htype_py,  str_py));
-		return -1;
-	}
-
-	return 0;
+  if (value->bm == NULL) {
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s: keyword \"%.200s\" %.200s, invalidated sequence",
+                 opname,
+                 slot_name,
+                 descr);
+    return -1;
+  }
+  else if (value->bm != bm) { /* we may want to make this check optional by setting 'bm' to NULL */
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s: keyword \"%.200s\" %.200s, invalidated sequence",
+                 opname,
+                 slot_name,
+                 descr);
+    return -1;
+  }
+  else if ((htype_py & htype_bmo) == 0) {
+    char str_bmo[32];
+    char str_py[32];
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s: keyword \"%.200s\" %.200s, expected "
+                 "a sequence of %.200s not %.200s",
+                 opname,
+                 slot_name,
+                 descr,
+                 BPy_BMElem_StringFromHType_ex(htype_bmo, str_bmo),
+                 BPy_BMElem_StringFromHType_ex(htype_py, str_py));
+    return -1;
+  }
+
+  return 0;
 }
 
 /**
  * Use for giving py args to an operator.
  */
-static int bpy_slot_from_py(
-        BMesh *bm, BMOperator *bmop, BMOpSlot *slot, PyObject *value,
-        /* the are just for exception messages */
-        const char *opname, const char *slot_name)
+static int bpy_slot_from_py(BMesh *bm,
+                            BMOperator *bmop,
+                            BMOpSlot *slot,
+                            PyObject *value,
+                            /* the are just for exception messages */
+                            const char *opname,
+                            const char *slot_name)
 {
-	switch (slot->slot_type) {
-		case BMO_OP_SLOT_BOOL:
-		{
-			const int param = PyC_Long_AsBool(value);
-
-			if (param == -1) {
-				PyErr_Format(PyExc_TypeError,
-				             "%.200s: keyword \"%.200s\" expected True/False or 0/1, not %.200s",
-				             opname, slot_name, Py_TYPE(value)->tp_name);
-				return -1;
-			}
-			else {
-				BMO_SLOT_AS_BOOL(slot) = param;
-			}
-
-			break;
-		}
-		case BMO_OP_SLOT_INT:
-		{
-			if (slot->slot_subtype.intg == BMO_OP_SLOT_SUBTYPE_INT_ENUM) {
-				int enum_val = -1;
-				PyC_FlagSet *items = (PyC_FlagSet *)slot->data.enum_data.flags;
-				const char *enum_str = _PyUnicode_AsString(value);
-
-				if (enum_str == NULL) {
-					PyErr_Format(PyExc_TypeError,
-					             "%.200s: keyword \"%.200s\" expected a string, not %.200s",
-					             opname, slot_name, Py_TYPE(value)->tp_name);
-					return -1;
-				}
-
-				if (PyC_FlagSet_ValueFromID(items, enum_str, &enum_val, slot_name) == -1) {
-					return -1;
-				}
-
-				BMO_SLOT_AS_INT(slot) = enum_val;
-			}
-			else if (slot->slot_subtype.intg == BMO_OP_SLOT_SUBTYPE_INT_FLAG) {
-				int flag = 0;
-				PyC_FlagSet *items = (PyC_FlagSet *)slot->data.enum_data.flags;
-
-				if (PyC_FlagSet_ToBitfield(items, value, &flag, slot_name) == -1) {
-					return -1;
-				}
-
-				BMO_SLOT_AS_INT(slot) = flag;
-			}
-			else {
-				const int param = PyC_Long_AsI32(value);
-
-				if (param == -1 && PyErr_Occurred()) {
-					PyErr_Format(PyExc_TypeError,
-					             "%.200s: keyword \"%.200s\" expected an int, not %.200s",
-					             opname, slot_name, Py_TYPE(value)->tp_name);
-					return -1;
-				}
-				else {
-					BMO_SLOT_AS_INT(slot) = param;
-				}
-			}
-			break;
-		}
-		case BMO_OP_SLOT_FLT:
-		{
-			float param = PyFloat_AsDouble(value);
-			if (param == -1 && PyErr_Occurred()) {
-				PyErr_Format(PyExc_TypeError,
-				             "%.200s: keyword \"%.200s\" expected a float, not %.200s",
-				             opname, slot_name, Py_TYPE(value)->tp_name);
-				return -1;
-			}
-			else {
-				BMO_SLOT_AS_FLOAT(slot) = param;
-			}
-			break;
-		}
-		case BMO_OP_SLOT_MAT:
-		{
-			/* XXX - BMesh operator design is crappy here, operator slot should define matrix size,
-			 * not the caller! */
-			MatrixObject *pymat;
-			if (!Matrix_ParseAny(value, &pymat)) {
-				return -1;
-			}
-			const ushort size = pymat->num_col;
-			if ((size != pymat->num_row) || (!ELEM(size, 3, 4))) {
-				PyErr_Format(PyExc_TypeError,
-				             "%.200s: keyword \"%.200s\" expected a 3x3 or 4x4 matrix Matrix",
-				             opname, slot_name);
-				return -1;
-			}
-
-			BMO_slot_mat_set(bmop, bmop->slots_in, slot_name, pymat->matrix, size);
-			break;
-		}
-		case BMO_OP_SLOT_VEC:
-		{
-			/* passing slot name here is a bit non-descriptive */
-			if (mathutils_array_parse(BMO_SLOT_AS_VECTOR(slot), 3, 3, value, slot_name) == -1) {
-				return -1;
-			}
-			break;
-		}
-		case BMO_OP_SLOT_ELEMENT_BUF:
-		{
-			if (slot->slot_subtype.elem & BMO_OP_SLOT_SUBTYPE_ELEM_IS_SINGLE) {
-				if (bpy_slot_from_py_elem_check((BPy_BMElem *)value, bm, (slot->slot_subtype.elem & BM_ALL_NOLOOP),
-				                                opname, slot_name, "single element") == -1)
-				{
-					return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-				}
-
-				BMO_slot_buffer_from_single(bmop, slot, &((BPy_BMElem *)value)->ele->head);
-			}
-			else {
-				/* there are many ways we could interpret arguments, for now...
-				 * - verts/edges/faces from the mesh direct,
-				 *   this way the operator takes every item.
-				 * - `TODO` a plain python sequence (list) of elements.
-				 * - `TODO`  an iterator. eg.
-				 *   face.verts
-				 * - `TODO`  (type, flag) pair, eg.
-				 *   ('VERT', {'TAG'})
-				 */
-
-				if (BPy_BMVertSeq_Check(value)) {
-					if (bpy_slot_from_py_elemseq_check((BPy_BMGeneric *)value, bm,
-					                                   BM_VERT, (slot->slot_subtype.elem & BM_ALL_NOLOOP),
-					                                   opname, slot_name, "element buffer") == -1)
-					{
-						return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-					}
-
-					BMO_slot_buffer_from_all(bm, bmop, bmop->slots_in, slot_name, BM_VERT);
-				}
-				else if (BPy_BMEdgeSeq_Check(value)) {
-					if (bpy_slot_from_py_elemseq_check((BPy_BMGeneric *)value, bm,
-					                                   BM_EDGE, (slot->slot_subtype.elem & BM_ALL_NOLOOP),
-					                                   opname, slot_name, "element buffer") == -1)
-					{
-						return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-					}
-
-					BMO_slot_buffer_from_all(bm, bmop, bmop->slots_in, slot_name, BM_EDGE);
-				}
-				else if (BPy_BMFaceSeq_Check(value)) {
-					if (bpy_slot_from_py_elemseq_check((BPy_BMGeneric *)value, bm,
-					                                   BM_FACE, (slot->slot_subtype.elem & BM_ALL_NOLOOP),
-					                                   opname, slot_name, "element buffer") == -1)
-					{
-						return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-					}
-					BMO_slot_buffer_from_all(bm, bmop, bmop->slots_in, slot_name, BM_FACE);
-				}
-
-				else if (BPy_BMElemSeq_Check(value)) {
-					BMIter iter;
-					BMHeader *ele;
-					int tot;
-					unsigned int i;
-
-					if (bpy_slot_from_py_elemseq_check((BPy_BMGeneric *)value, bm,
-					                                   bm_iter_itype_htype_map[((BPy_BMElemSeq *)value)->itype],
-					                                   (slot->slot_subtype.elem & BM_ALL_NOLOOP),
-					                                   opname, slot_name, "element buffer") == -1)
-					{
-						return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-					}
-
-					/* this will loop over all elements which is a shame but
-					 * we need to know this before alloc */
-					/* calls bpy_bmelemseq_length() */
-					tot = Py_TYPE(value)->tp_as_sequence->sq_length(value);
-
-					BMO_slot_buffer_alloc(bmop, bmop->slots_in, slot_name, tot);
-
-					i = 0;
-					BM_ITER_BPY_BM_SEQ (ele, &iter, ((BPy_BMElemSeq *)value)) {
-						slot->data.buf[i] = ele;
-						i++;
-					}
-				}
-				/* keep this last */
-				else if (PySequence_Check(value)) {
-					BMElem **elem_array = NULL;
-					Py_ssize_t elem_array_len;
-
-					elem_array = BPy_BMElem_PySeq_As_Array(&bm, value, 0, PY_SSIZE_T_MAX,
-					                                       &elem_array_len, (slot->slot_subtype.elem & BM_ALL_NOLOOP),
-					                                       true, true, slot_name);
-
-					/* error is set above */
-					if (elem_array == NULL) {
-						return -1;
-					}
-
-					BMO_slot_buffer_alloc(bmop, bmop->slots_in, slot_name, elem_array_len);
-					memcpy(slot->data.buf, elem_array, sizeof(void *) * elem_array_len);
-					PyMem_FREE(elem_array);
-				}
-				else {
-					PyErr_Format(PyExc_TypeError,
-					             "%.200s: keyword \"%.200s\" expected "
-					             "a bmesh sequence, list, (htype, flag) pair, not %.200s",
-					             opname, slot_name, Py_TYPE(value)->tp_name);
-					return -1;
-				}
-			}
-			break;
-		}
-		case BMO_OP_SLOT_MAPPING:
-		{
-			/* first check types */
-			if (slot->slot_subtype.map != BMO_OP_SLOT_SUBTYPE_MAP_EMPTY) {
-				if (!PyDict_Check(value)) {
-					PyErr_Format(PyExc_TypeError,
-					             "%.200s: keyword \"%.200s\" expected "
-					             "a dict, not %.200s",
-					             opname, slot_name, Py_TYPE(value)->tp_name);
-					return -1;
-				}
-			}
-			else {
-				if (!PySet_Check(value)) {
-					PyErr_Format(PyExc_TypeError,
-					             "%.200s: keyword \"%.200s\" expected "
-					             "a set, not %.200s",
-					             opname, slot_name, Py_TYPE(value)->tp_name);
-					return -1;
-				}
-			}
-
-			switch (slot->slot_subtype.map) {
-				case BMO_OP_SLOT_SUBTYPE_MAP_ELEM:
-				{
-					if (PyDict_Size(value) > 0) {
-						PyObject *arg_key, *arg_value;
-						Py_ssize_t arg_pos = 0;
-						while (PyDict_Next(value, &arg_pos, &arg_key, &arg_value)) {
-							if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key, bm, BM_ALL_NOLOOP,
-							                                opname, slot_name, "invalid key in dict") == -1)
-							{
-								return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-							}
-
-							if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_value, bm, BM_ALL_NOLOOP,
-							                                opname, slot_name, "invalid value in dict") == -1)
-							{
-								return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-							}
-
-							BMO_slot_map_elem_insert(bmop, slot,
-							                         ((BPy_BMElem *)arg_key)->ele, ((BPy_BMElem *)arg_value)->ele);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_FLT:
-				{
-					if (PyDict_Size(value) > 0) {
-						PyObject *arg_key, *arg_value;
-						Py_ssize_t arg_pos = 0;
-						while (PyDict_Next(value, &arg_pos, &arg_key, &arg_value)) {
-							float value_f;
-
-							if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key, bm, BM_ALL_NOLOOP,
-							                                opname, slot_name, "invalid key in dict") == -1)
-							{
-								return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-							}
-
-							value_f = PyFloat_AsDouble(arg_value);
-
-							if (value_f == -1.0f && PyErr_Occurred()) {
-								PyErr_Format(PyExc_TypeError,
-								             "%.200s: keyword \"%.200s\" expected "
-								             "a dict with float values, not %.200s",
-								             opname, slot_name, Py_TYPE(arg_value)->tp_name);
-								return -1;
-							}
-
-							BMO_slot_map_float_insert(bmop, slot,
-							                          ((BPy_BMElem *)arg_key)->ele, value_f);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_INT:
-				{
-					if (PyDict_Size(value) > 0) {
-						PyObject *arg_key, *arg_value;
-						Py_ssize_t arg_pos = 0;
-						while (PyDict_Next(value, &arg_pos, &arg_key, &arg_value)) {
-							int value_i;
-
-							if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key, bm, BM_ALL_NOLOOP,
-							                                opname, slot_name, "invalid key in dict") == -1)
-							{
-								return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-							}
-
-							value_i = PyC_Long_AsI32(arg_value);
-
-							if (value_i == -1 && PyErr_Occurred()) {
-								PyErr_Format(PyExc_TypeError,
-								             "%.200s: keyword \"%.200s\" expected "
-								             "a dict with int values, not %.200s",
-								             opname, slot_name, Py_TYPE(arg_value)->tp_name);
-								return -1;
-							}
-
-							BMO_slot_map_int_insert(bmop, slot,
-							                        ((BPy_BMElem *)arg_key)->ele, value_i);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_BOOL:
-				{
-					if (PyDict_Size(value) > 0) {
-						PyObject *arg_key, *arg_value;
-						Py_ssize_t arg_pos = 0;
-						while (PyDict_Next(value, &arg_pos, &arg_key, &arg_value)) {
-							int value_i;
-
-							if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key, bm, BM_ALL_NOLOOP,
-							                                opname, slot_name, "invalid key in dict") == -1)
-							{
-								return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-							}
-
-							value_i = PyC_Long_AsI32(arg_value);
-
-							if (value_i == -1 && PyErr_Occurred()) {
-								PyErr_Format(PyExc_TypeError,
-								             "%.200s: keyword \"%.200s\" expected "
-								             "a dict with bool values, not %.200s",
-								             opname, slot_name, Py_TYPE(arg_value)->tp_name);
-								return -1;
-							}
-
-							BMO_slot_map_bool_insert(bmop, slot,
-							                         ((BPy_BMElem *)arg_key)->ele, value_i != 0);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_EMPTY:
-				{
-					if (PySet_Size(value) > 0) {
-						PyObject *arg_key;
-						Py_ssize_t arg_pos = 0;
-						Py_ssize_t arg_hash = 0;
-						while (_PySet_NextEntry(value, &arg_pos, &arg_key, &arg_hash)) {
-
-							if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key, bm, BM_ALL_NOLOOP,
-							                                opname, slot_name, "invalid key in set") == -1)
-							{
-								return -1;  /* error is set in bpy_slot_from_py_elem_check() */
-							}
-
-							BMO_slot_map_empty_insert(bmop, slot,
-							                         ((BPy_BMElem *)arg_key)->ele);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL:
-				{
-					/* can't convert from these */
-					PyErr_Format(PyExc_NotImplementedError,
-					             "This arguments mapping subtype %d is not supported", slot->slot_subtype.map);
-					return -1;
-				}
-			}
-			break;
-		}
-		default:
-			/* TODO --- many others */
-			PyErr_Format(PyExc_NotImplementedError,
-			             "%.200s: keyword \"%.200s\" type %d not working yet!",
-			             opname, slot_name, slot->slot_type);
-			return -1;
-	}
-
-	/* all is well */
-	return 0;
+  switch (slot->slot_type) {
+    case BMO_OP_SLOT_BOOL: {
+      const int param = PyC_Long_AsBool(value);
+
+      if (param == -1) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s: keyword \"%.200s\" expected True/False or 0/1, not %.200s",
+                     opname,
+                     slot_name,
+                     Py_TYPE(value)->tp_name);
+        return -1;
+      }
+      else {
+        BMO_SLOT_AS_BOOL(slot) = param;
+      }
+
+      break;
+    }
+    case BMO_OP_SLOT_INT: {
+      if (slot->slot_subtype.intg == BMO_OP_SLOT_SUBTYPE_INT_ENUM) {
+        int enum_val = -1;
+        PyC_FlagSet *items = (PyC_FlagSet *)slot->data.enum_data.flags;
+        const char *enum_str = _PyUnicode_AsString(value);
+
+        if (enum_str == NULL) {
+          PyErr_Format(PyExc_TypeError,
+                       "%.200s: keyword \"%.200s\" expected a string, not %.200s",
+                       opname,
+                       slot_name,
+                       Py_TYPE(value)->tp_name);
+          return -1;
+        }
+
+        if (PyC_FlagSet_ValueFromID(items, enum_str, &enum_val, slot_name) == -1) {
+          return -1;
+        }
+
+        BMO_SLOT_AS_INT(slot) = enum_val;
+      }
+      else if (slot->slot_subtype.intg == BMO_OP_SLOT_SUBTYPE_INT_FLAG) {
+        int flag = 0;
+        PyC_FlagSet *items = (PyC_FlagSet *)slot->data.enum_data.flags;
+
+        if (PyC_FlagSet_ToBitfield(items, value, &flag, slot_name) == -1) {
+          return -1;
+        }
+
+        BMO_SLOT_AS_INT(slot) = flag;
+      }
+      else {
+        const int param = PyC_Long_AsI32(value);
+
+        if (param == -1 && PyErr_Occurred()) {
+          PyErr_Format(PyExc_TypeError,
+                       "%.200s: keyword \"%.200s\" expected an int, not %.200s",
+                       opname,
+                       slot_name,
+                       Py_TYPE(value)->tp_name);
+          return -1;
+        }
+        else {
+          BMO_SLOT_AS_INT(slot) = param;
+        }
+      }
+      break;
+    }
+    case BMO_OP_SLOT_FLT: {
+      float param = PyFloat_AsDouble(value);
+      if (param == -1 && PyErr_Occurred()) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s: keyword \"%.200s\" expected a float, not %.200s",
+                     opname,
+                     slot_name,
+                     Py_TYPE(value)->tp_name);
+        return -1;
+      }
+      else {
+        BMO_SLOT_AS_FLOAT(slot) = param;
+      }
+      break;
+    }
+    case BMO_OP_SLOT_MAT: {
+      /* XXX - BMesh operator design is crappy here, operator slot should define matrix size,
+       * not the caller! */
+      MatrixObject *pymat;
+      if (!Matrix_ParseAny(value, &pymat)) {
+        return -1;
+      }
+      const ushort size = pymat->num_col;
+      if ((size != pymat->num_row) || (!ELEM(size, 3, 4))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s: keyword \"%.200s\" expected a 3x3 or 4x4 matrix Matrix",
+                     opname,
+                     slot_name);
+        return -1;
+      }
+
+      BMO_slot_mat_set(bmop, bmop->slots_in, slot_name, pymat->matrix, size);
+      break;
+    }
+    case BMO_OP_SLOT_VEC: {
+      /* passing slot name here is a bit non-descriptive */
+      if (mathutils_array_parse(BMO_SLOT_AS_VECTOR(slot), 3, 3, value, slot_name) == -1) {
+        return -1;
+      }
+      break;
+    }
+    case BMO_OP_SLOT_ELEMENT_BUF: {
+      if (slot->slot_subtype.elem & BMO_OP_SLOT_SUBTYPE_ELEM_IS_SINGLE) {
+        if (bpy_slot_from_py_elem_check((BPy_BMElem *)value,
+                                        bm,
+                                        (slot->slot_subtype.elem & BM_ALL_NOLOOP),
+                                        opname,
+                                        slot_name,
+                                        "single element") == -1) {
+          return -1; /* error is set in bpy_slot_from_py_elem_check() */
+        }
+
+        BMO_slot_buffer_from_single(bmop, slot, &((BPy_BMElem *)value)->ele->head);
+      }
+      else {
+        /* there are many ways we could interpret arguments, for now...
+         * - verts/edges/faces from the mesh direct,
+         *   this way the operator takes every item.
+         * - `TODO` a plain python sequence (list) of elements.
+         * - `TODO`  an iterator. eg.
+         *   face.verts
+         * - `TODO`  (type, flag) pair, eg.
+         *   ('VERT', {'TAG'})
+         */
+
+        if (BPy_BMVertSeq_Check(value)) {
+          if (bpy_slot_from_py_elemseq_check((BPy_BMGeneric *)value,
+                                             bm,
+                                             BM_VERT,
+                                             (slot->slot_subtype.elem & BM_ALL_NOLOOP),
+                                             opname,
+                                             slot_name,
+                                             "element buffer") == -1) {
+            return -1; /* error is set in bpy_slot_from_py_elem_check() */
+          }
+
+          BMO_slot_buffer_from_all(bm, bmop, bmop->slots_in, slot_name, BM_VERT);
+        }
+        else if (BPy_BMEdgeSeq_Check(value)) {
+          if (bpy_slot_from_py_elemseq_check((BPy_BMGeneric *)value,
+                                             bm,
+                                             BM_EDGE,
+                                             (slot->slot_subtype.elem & BM_ALL_NOLOOP),
+                                             opname,
+                                             slot_name,
+                                             "element buffer") == -1) {
+            return -1; /* error is set in bpy_slot_from_py_elem_check() */
+          }
+
+          BMO_slot_buffer_from_all(bm, bmop, bmop->slots_in, slot_name, BM_EDGE);
+        }
+        else if (BPy_BMFaceSeq_Check(value)) {
+          if (bpy_slot_from_py_elemseq_check((BPy_BMGeneric *)value,
+                                             bm,
+                                             BM_FACE,
+                                             (slot->slot_subtype.elem & BM_ALL_NOLOOP),
+                                             opname,
+                                             slot_name,
+                                             "element buffer") == -1) {
+            return -1; /* error is set in bpy_slot_from_py_elem_check() */
+          }
+          BMO_slot_buffer_from_all(bm, bmop, bmop->slots_in, slot_name, BM_FACE);
+        }
+
+        else if (BPy_BMElemSeq_Check(value)) {
+          BMIter iter;
+          BMHeader *ele;
+          int tot;
+          unsigned int i;
+
+          if (bpy_slot_from_py_elemseq_check(
+                  (BPy_BMGeneric *)value,
+                  bm,
+                  bm_iter_itype_htype_map[((BPy_BMElemSeq *)value)->itype],
+                  (slot->slot_subtype.elem & BM_ALL_NOLOOP),
+                  opname,
+                  slot_name,
+                  "element buffer") == -1) {
+            return -1; /* error is set in bpy_slot_from_py_elem_check() */
+          }
+
+          /* this will loop over all elements which is a shame but
+           * we need to know this before alloc */
+          /* calls bpy_bmelemseq_length() */
+          tot = Py_TYPE(value)->tp_as_sequence->sq_length(value);
+
+          BMO_slot_buffer_alloc(bmop, bmop->slots_in, slot_name, tot);
+
+          i = 0;
+          BM_ITER_BPY_BM_SEQ(ele, &iter, ((BPy_BMElemSeq *)value))
+          {
+            slot->data.buf[i] = ele;
+            i++;
+          }
+        }
+        /* keep this last */
+        else if (PySequence_Check(value)) {
+          BMElem **elem_array = NULL;
+          Py_ssize_t elem_array_len;
+
+          elem_array = BPy_BMElem_PySeq_As_Array(&bm,
+                                                 value,
+                                                 0,
+                                                 PY_SSIZE_T_MAX,
+                                                 &elem_array_len,
+                                                 (slot->slot_subtype.elem & BM_ALL_NOLOOP),
+                                                 true,
+                                                 true,
+                                                 slot_name);
+
+          /* error is set above */
+          if (elem_array == NULL) {
+            return -1;
+          }
+
+          BMO_slot_buffer_alloc(bmop, bmop->slots_in, slot_name, elem_array_len);
+          memcpy(slot->data.buf, elem_array, sizeof(void *) * elem_array_len);
+          PyMem_FREE(elem_array);
+        }
+        else {
+          PyErr_Format(PyExc_TypeError,
+                       "%.200s: keyword \"%.200s\" expected "
+                       "a bmesh sequence, list, (htype, flag) pair, not %.200s",
+                       opname,
+                       slot_name,
+                       Py_TYPE(value)->tp_name);
+          return -1;
+        }
+      }
+      break;
+    }
+    case BMO_OP_SLOT_MAPPING: {
+      /* first check types */
+      if (slot->slot_subtype.map != BMO_OP_SLOT_SUBTYPE_MAP_EMPTY) {
+        if (!PyDict_Check(value)) {
+          PyErr_Format(PyExc_TypeError,
+                       "%.200s: keyword \"%.200s\" expected "
+                       "a dict, not %.200s",
+                       opname,
+                       slot_name,
+                       Py_TYPE(value)->tp_name);
+          return -1;
+        }
+      }
+      else {
+        if (!PySet_Check(value)) {
+          PyErr_Format(PyExc_TypeError,
+                       "%.200s: keyword \"%.200s\" expected "
+                       "a set, not %.200s",
+                       opname,
+                       slot_name,
+                       Py_TYPE(value)->tp_name);
+          return -1;
+        }
+      }
+
+      switch (slot->slot_subtype.map) {
+        case BMO_OP_SLOT_SUBTYPE_MAP_ELEM: {
+          if (PyDict_Size(value) > 0) {
+            PyObject *arg_key, *arg_value;
+            Py_ssize_t arg_pos = 0;
+            while (PyDict_Next(value, &arg_pos, &arg_key, &arg_value)) {
+              if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key,
+                                              bm,
+                                              BM_ALL_NOLOOP,
+                                              opname,
+                                              slot_name,
+                                              "invalid key in dict") == -1) {
+                return -1; /* error is set in bpy_slot_from_py_elem_check() */
+              }
+
+              if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_value,
+                                              bm,
+                                              BM_ALL_NOLOOP,
+                                              opname,
+                                              slot_name,
+                                              "invalid value in dict") == -1) {
+                return -1; /* error is set in bpy_slot_from_py_elem_check() */
+              }
+
+              BMO_slot_map_elem_insert(
+                  bmop, slot, ((BPy_BMElem *)arg_key)->ele, ((BPy_BMElem *)arg_value)->ele);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_FLT: {
+          if (PyDict_Size(value) > 0) {
+            PyObject *arg_key, *arg_value;
+            Py_ssize_t arg_pos = 0;
+            while (PyDict_Next(value, &arg_pos, &arg_key, &arg_value)) {
+              float value_f;
+
+              if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key,
+                                              bm,
+                                              BM_ALL_NOLOOP,
+                                              opname,
+                                              slot_name,
+                                              "invalid key in dict") == -1) {
+                return -1; /* error is set in bpy_slot_from_py_elem_check() */
+              }
+
+              value_f = PyFloat_AsDouble(arg_value);
+
+              if (value_f == -1.0f && PyErr_Occurred()) {
+                PyErr_Format(PyExc_TypeError,
+                             "%.200s: keyword \"%.200s\" expected "
+                             "a dict with float values, not %.200s",
+                             opname,
+                             slot_name,
+                             Py_TYPE(arg_value)->tp_name);
+                return -1;
+              }
+
+              BMO_slot_map_float_insert(bmop, slot, ((BPy_BMElem *)arg_key)->ele, value_f);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_INT: {
+          if (PyDict_Size(value) > 0) {
+            PyObject *arg_key, *arg_value;
+            Py_ssize_t arg_pos = 0;
+            while (PyDict_Next(value, &arg_pos, &arg_key, &arg_value)) {
+              int value_i;
+
+              if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key,
+                                              bm,
+                                              BM_ALL_NOLOOP,
+                                              opname,
+                                              slot_name,
+                                              "invalid key in dict") == -1) {
+                return -1; /* error is set in bpy_slot_from_py_elem_check() */
+              }
+
+              value_i = PyC_Long_AsI32(arg_value);
+
+              if (value_i == -1 && PyErr_Occurred()) {
+                PyErr_Format(PyExc_TypeError,
+                             "%.200s: keyword \"%.200s\" expected "
+                             "a dict with int values, not %.200s",
+                             opname,
+                             slot_name,
+                             Py_TYPE(arg_value)->tp_name);
+                return -1;
+              }
+
+              BMO_slot_map_int_insert(bmop, slot, ((BPy_BMElem *)arg_key)->ele, value_i);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_BOOL: {
+          if (PyDict_Size(value) > 0) {
+            PyObject *arg_key, *arg_value;
+            Py_ssize_t arg_pos = 0;
+            while (PyDict_Next(value, &arg_pos, &arg_key, &arg_value)) {
+              int value_i;
+
+              if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key,
+                                              bm,
+                                              BM_ALL_NOLOOP,
+                                              opname,
+                                              slot_name,
+                                              "invalid key in dict") == -1) {
+                return -1; /* error is set in bpy_slot_from_py_elem_check() */
+              }
+
+              value_i = PyC_Long_AsI32(arg_value);
+
+              if (value_i == -1 && PyErr_Occurred()) {
+                PyErr_Format(PyExc_TypeError,
+                             "%.200s: keyword \"%.200s\" expected "
+                             "a dict with bool values, not %.200s",
+                             opname,
+                             slot_name,
+                             Py_TYPE(arg_value)->tp_name);
+                return -1;
+              }
+
+              BMO_slot_map_bool_insert(bmop, slot, ((BPy_BMElem *)arg_key)->ele, value_i != 0);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_EMPTY: {
+          if (PySet_Size(value) > 0) {
+            PyObject *arg_key;
+            Py_ssize_t arg_pos = 0;
+            Py_ssize_t arg_hash = 0;
+            while (_PySet_NextEntry(value, &arg_pos, &arg_key, &arg_hash)) {
+
+              if (bpy_slot_from_py_elem_check((BPy_BMElem *)arg_key,
+                                              bm,
+                                              BM_ALL_NOLOOP,
+                                              opname,
+                                              slot_name,
+                                              "invalid key in set") == -1) {
+                return -1; /* error is set in bpy_slot_from_py_elem_check() */
+              }
+
+              BMO_slot_map_empty_insert(bmop, slot, ((BPy_BMElem *)arg_key)->ele);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL: {
+          /* can't convert from these */
+          PyErr_Format(PyExc_NotImplementedError,
+                       "This arguments mapping subtype %d is not supported",
+                       slot->slot_subtype.map);
+          return -1;
+        }
+      }
+      break;
+    }
+    default:
+      /* TODO --- many others */
+      PyErr_Format(PyExc_NotImplementedError,
+                   "%.200s: keyword \"%.200s\" type %d not working yet!",
+                   opname,
+                   slot_name,
+                   slot->slot_type);
+      return -1;
+  }
+
+  /* all is well */
+  return 0;
 }
 
 /**
@@ -542,153 +606,146 @@ static int bpy_slot_from_py(
  */
 static PyObject *bpy_slot_to_py(BMesh *bm, BMOpSlot *slot)
 {
-	PyObject *item = NULL;
-
-	/* keep switch in same order as above */
-	switch (slot->slot_type) {
-		case BMO_OP_SLOT_BOOL:
-			item = PyBool_FromLong((BMO_SLOT_AS_BOOL(slot)));
-			break;
-		case BMO_OP_SLOT_INT:
-			item = PyLong_FromLong(BMO_SLOT_AS_INT(slot));
-			break;
-		case BMO_OP_SLOT_FLT:
-			item = PyFloat_FromDouble((double)BMO_SLOT_AS_FLOAT(slot));
-			break;
-		case BMO_OP_SLOT_MAT:
-			item = Matrix_CreatePyObject((float *)BMO_SLOT_AS_MATRIX(slot), 4, 4, NULL);
-			break;
-		case BMO_OP_SLOT_VEC:
-			item = Vector_CreatePyObject(BMO_SLOT_AS_VECTOR(slot), slot->len, NULL);
-			break;
-		case BMO_OP_SLOT_PTR:
-			BLI_assert(0);  /* currently we don't have any pointer return values in use */
-			item = Py_INCREF_RET(Py_None);
-			break;
-		case BMO_OP_SLOT_ELEMENT_BUF:
-		{
-			if (slot->slot_subtype.elem & BMO_OP_SLOT_SUBTYPE_ELEM_IS_SINGLE) {
-				BMHeader *ele = BMO_slot_buffer_get_single(slot);
-				item = ele ? BPy_BMElem_CreatePyObject(bm, ele) : Py_INCREF_RET(Py_None);
-			}
-			else {
-				const int size = slot->len;
-				void **buffer = BMO_SLOT_AS_BUFFER(slot);
-				int j;
-
-				item = PyList_New(size);
-				for (j = 0; j < size; j++) {
-					BMHeader *ele = buffer[j];
-					PyList_SET_ITEM(item, j, BPy_BMElem_CreatePyObject(bm, ele));
-				}
-			}
-			break;
-		}
-		case BMO_OP_SLOT_MAPPING:
-		{
-			GHash *slot_hash = BMO_SLOT_AS_GHASH(slot);
-			GHashIterator hash_iter;
-
-			switch (slot->slot_subtype.map) {
-				case BMO_OP_SLOT_SUBTYPE_MAP_ELEM:
-				{
-					item = _PyDict_NewPresized(slot_hash ? BLI_ghash_len(slot_hash) : 0);
-					if (slot_hash) {
-						GHASH_ITER (hash_iter, slot_hash) {
-							BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
-							void     *ele_val = BLI_ghashIterator_getValue(&hash_iter);
-
-							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm, ele_key);
-							PyObject *py_val =  BPy_BMElem_CreatePyObject(bm, ele_val);
-
-							PyDict_SetItem(item, py_key, py_val);
-							Py_DECREF(py_key);
-							Py_DECREF(py_val);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_FLT:
-				{
-					item = _PyDict_NewPresized(slot_hash ? BLI_ghash_len(slot_hash) : 0);
-					if (slot_hash) {
-						GHASH_ITER (hash_iter, slot_hash) {
-							BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
-							void     *ele_val = BLI_ghashIterator_getValue(&hash_iter);
-
-							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm,  ele_key);
-							PyObject *py_val =  PyFloat_FromDouble(*(float *)&ele_val);
-
-							PyDict_SetItem(item, py_key, py_val);
-							Py_DECREF(py_key);
-							Py_DECREF(py_val);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_INT:
-				{
-					item = _PyDict_NewPresized(slot_hash ? BLI_ghash_len(slot_hash) : 0);
-					if (slot_hash) {
-						GHASH_ITER (hash_iter, slot_hash) {
-							BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
-							void     *ele_val = BLI_ghashIterator_getValue(&hash_iter);
-
-							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm,  ele_key);
-							PyObject *py_val =  PyLong_FromLong(*(int *)&ele_val);
-
-							PyDict_SetItem(item, py_key, py_val);
-							Py_DECREF(py_key);
-							Py_DECREF(py_val);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_BOOL:
-				{
-					item = _PyDict_NewPresized(slot_hash ? BLI_ghash_len(slot_hash) : 0);
-					if (slot_hash) {
-						GHASH_ITER (hash_iter, slot_hash) {
-							BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
-							void     *ele_val = BLI_ghashIterator_getValue(&hash_iter);
-
-							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm,  ele_key);
-							PyObject *py_val =  PyBool_FromLong(*(bool *)&ele_val);
-
-							PyDict_SetItem(item, py_key, py_val);
-							Py_DECREF(py_key);
-							Py_DECREF(py_val);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_EMPTY:
-				{
-					item = PySet_New(NULL);
-					if (slot_hash) {
-						GHASH_ITER (hash_iter, slot_hash) {
-							BMHeader       *ele_key = BLI_ghashIterator_getKey(&hash_iter);
-
-							PyObject *py_key =  BPy_BMElem_CreatePyObject(bm,  ele_key);
-
-							PySet_Add(item, py_key);
-
-							Py_DECREF(py_key);
-						}
-					}
-					break;
-				}
-				case BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL:
-					/* can't convert from these */
-					item = Py_INCREF_RET(Py_None);
-					break;
-			}
-			break;
-		}
-	}
-	BLI_assert(item != NULL);
-
-	return item;
+  PyObject *item = NULL;
+
+  /* keep switch in same order as above */
+  switch (slot->slot_type) {
+    case BMO_OP_SLOT_BOOL:
+      item = PyBool_FromLong((BMO_SLOT_AS_BOOL(slot)));
+      break;
+    case BMO_OP_SLOT_INT:
+      item = PyLong_FromLong(BMO_SLOT_AS_INT(slot));
+      break;
+    case BMO_OP_SLOT_FLT:
+      item = PyFloat_FromDouble((double)BMO_SLOT_AS_FLOAT(slot));
+      break;
+    case BMO_OP_SLOT_MAT:
+      item = Matrix_CreatePyObject((float *)BMO_SLOT_AS_MATRIX(slot), 4, 4, NULL);
+      break;
+    case BMO_OP_SLOT_VEC:
+      item = Vector_CreatePyObject(BMO_SLOT_AS_VECTOR(slot), slot->len, NULL);
+      break;
+    case BMO_OP_SLOT_PTR:
+      BLI_assert(0); /* currently we don't have any pointer return values in use */
+      item = Py_INCREF_RET(Py_None);
+      break;
+    case BMO_OP_SLOT_ELEMENT_BUF: {
+      if (slot->slot_subtype.elem & BMO_OP_SLOT_SUBTYPE_ELEM_IS_SINGLE) {
+        BMHeader *ele = BMO_slot_buffer_get_single(slot);
+        item = ele ? BPy_BMElem_CreatePyObject(bm, ele) : Py_INCREF_RET(Py_None);
+      }
+      else {
+        const int size = slot->len;
+        void **buffer = BMO_SLOT_AS_BUFFER(slot);
+        int j;
+
+        item = PyList_New(size);
+        for (j = 0; j < size; j++) {
+          BMHeader *ele = buffer[j];
+          PyList_SET_ITEM(item, j, BPy_BMElem_CreatePyObject(bm, ele));
+        }
+      }
+      break;
+    }
+    case BMO_OP_SLOT_MAPPING: {
+      GHash *slot_hash = BMO_SLOT_AS_GHASH(slot);
+      GHashIterator hash_iter;
+
+      switch (slot->slot_subtype.map) {
+        case BMO_OP_SLOT_SUBTYPE_MAP_ELEM: {
+          item = _PyDict_NewPresized(slot_hash ? BLI_ghash_len(slot_hash) : 0);
+          if (slot_hash) {
+            GHASH_ITER (hash_iter, slot_hash) {
+              BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
+              void *ele_val = BLI_ghashIterator_getValue(&hash_iter);
+
+              PyObject *py_key = BPy_BMElem_CreatePyObject(bm, ele_key);
+              PyObject *py_val = BPy_BMElem_CreatePyObject(bm, ele_val);
+
+              PyDict_SetItem(item, py_key, py_val);
+              Py_DECREF(py_key);
+              Py_DECREF(py_val);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_FLT: {
+          item = _PyDict_NewPresized(slot_hash ? BLI_ghash_len(slot_hash) : 0);
+          if (slot_hash) {
+            GHASH_ITER (hash_iter, slot_hash) {
+              BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
+              void *ele_val = BLI_ghashIterator_getValue(&hash_iter);
+
+              PyObject *py_key = BPy_BMElem_CreatePyObject(bm, ele_key);
+              PyObject *py_val = PyFloat_FromDouble(*(float *)&ele_val);
+
+              PyDict_SetItem(item, py_key, py_val);
+              Py_DECREF(py_key);
+              Py_DECREF(py_val);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_INT: {
+          item = _PyDict_NewPresized(slot_hash ? BLI_ghash_len(slot_hash) : 0);
+          if (slot_hash) {
+            GHASH_ITER (hash_iter, slot_hash) {
+              BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
+              void *ele_val = BLI_ghashIterator_getValue(&hash_iter);
+
+              PyObject *py_key = BPy_BMElem_CreatePyObject(bm, ele_key);
+              PyObject *py_val = PyLong_FromLong(*(int *)&ele_val);
+
+              PyDict_SetItem(item, py_key, py_val);
+              Py_DECREF(py_key);
+              Py_DECREF(py_val);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_BOOL: {
+          item = _PyDict_NewPresized(slot_hash ? BLI_ghash_len(slot_hash) : 0);
+          if (slot_hash) {
+            GHASH_ITER (hash_iter, slot_hash) {
+              BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
+              void *ele_val = BLI_ghashIterator_getValue(&hash_iter);
+
+              PyObject *py_key = BPy_BMElem_CreatePyObject(bm, ele_key);
+              PyObject *py_val = PyBool_FromLong(*(bool *)&ele_val);
+
+              PyDict_SetItem(item, py_key, py_val);
+              Py_DECREF(py_key);
+              Py_DECREF(py_val);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_EMPTY: {
+          item = PySet_New(NULL);
+          if (slot_hash) {
+            GHASH_ITER (hash_iter, slot_hash) {
+              BMHeader *ele_key = BLI_ghashIterator_getKey(&hash_iter);
+
+              PyObject *py_key = BPy_BMElem_CreatePyObject(bm, ele_key);
+
+              PySet_Add(item, py_key);
+
+              Py_DECREF(py_key);
+            }
+          }
+          break;
+        }
+        case BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL:
+          /* can't convert from these */
+          item = Py_INCREF_RET(Py_None);
+          break;
+      }
+      break;
+    }
+  }
+  BLI_assert(item != NULL);
+
+  return item;
 }
 
 /**
@@ -696,112 +753,109 @@ static PyObject *bpy_slot_to_py(BMesh *bm, BMOpSlot *slot)
  */
 PyObject *BPy_BMO_call(BPy_BMeshOpFunc *self, PyObject *args, PyObject *kw)
 {
-	PyObject *ret;
-	BPy_BMesh *py_bm;
-	BMesh *bm;
-
-	BMOperator bmop;
-
-	if ((PyTuple_GET_SIZE(args) == 1) &&
-	    (py_bm = (BPy_BMesh *)PyTuple_GET_ITEM(args, 0)) &&
-	    (BPy_BMesh_Check(py_bm)))
-	{
-		BPY_BM_CHECK_OBJ(py_bm);
-		bm = py_bm->bm;
-
-		if (bm->use_toolflags == false) {
-			PyErr_SetString(PyExc_ValueError,
-			                "bmesh created with 'use_operators=False'");
-			return NULL;
-		}
-
-		/* could complain about entering with exceptions... */
-		BMO_error_clear(bm);
-	}
-	else {
-		PyErr_SetString(PyExc_TypeError,
-		                "bmesh operators expect a single BMesh positional argument, all other args must be keywords");
-		return NULL;
-	}
-
-	/* TODO - error check this!, though we do the error check on attribute access */
-	/* TODO - make flags optional */
-	BMO_op_init(bm, &bmop, BMO_FLAG_DEFAULTS, self->opname);
-
-	if (kw && PyDict_Size(kw) > 0) {
-		/* setup properties, see bpy_rna.c: pyrna_py_to_prop()
-		 * which shares this logic for parsing properties */
-
-		PyObject *key, *value;
-		Py_ssize_t pos = 0;
-		while (PyDict_Next(kw, &pos, &key, &value)) {
-			const char *slot_name = _PyUnicode_AsString(key);
-			BMOpSlot *slot;
-
-			if (!BMO_slot_exists(bmop.slots_in, slot_name)) {
-				PyErr_Format(PyExc_TypeError,
-				             "%.200s: keyword \"%.200s\" is invalid for this operator",
-				             self->opname, slot_name);
-				BMO_op_finish(bm, &bmop);
-				return NULL;
-			}
-
-			slot = BMO_slot_get(bmop.slots_in, slot_name);
-
-			/* now assign the value */
-			if (bpy_slot_from_py(bm, &bmop, slot, value,
-			                     self->opname, slot_name) == -1)
-			{
-				BMO_op_finish(bm, &bmop);
-				return NULL;
-			}
-		}
-	}
-
-	BMO_op_exec(bm, &bmop);
-
-	/* from here until the end of the function, no returns, just set 'ret' */
-	if (UNLIKELY(bpy_bm_op_as_py_error(bm) == -1)) {
-		ret = NULL;  /* exception raised above */
-	}
-	else if (bmop.slots_out[0].slot_name == NULL) {
-		ret = Py_INCREF_RET(Py_None);
-	}
-	else {
-		/* build return value */
-		int i;
-		ret = PyDict_New();
-
-		for (i = 0; bmop.slots_out[i].slot_name; i++) {
-			// BMOpDefine *op_def = opdefines[bmop.type];
-			// BMOSlotType *slot_type = op_def->slot_types_out[i];
-			BMOpSlot *slot = &bmop.slots_out[i];
-			PyObject *item;
-
-			/* this function doesn't throw exceptions */
-			item = bpy_slot_to_py(bm, slot);
-			if (item == NULL) {
-				item = Py_INCREF_RET(Py_None);
-			}
+  PyObject *ret;
+  BPy_BMesh *py_bm;
+  BMesh *bm;
+
+  BMOperator bmop;
+
+  if ((PyTuple_GET_SIZE(args) == 1) && (py_bm = (BPy_BMesh *)PyTuple_GET_ITEM(args, 0)) &&
+      (BPy_BMesh_Check(py_bm))) {
+    BPY_BM_CHECK_OBJ(py_bm);
+    bm = py_bm->bm;
+
+    if (bm->use_toolflags == false) {
+      PyErr_SetString(PyExc_ValueError, "bmesh created with 'use_operators=False'");
+      return NULL;
+    }
+
+    /* could complain about entering with exceptions... */
+    BMO_error_clear(bm);
+  }
+  else {
+    PyErr_SetString(PyExc_TypeError,
+                    "bmesh operators expect a single BMesh positional argument, all other args "
+                    "must be keywords");
+    return NULL;
+  }
+
+  /* TODO - error check this!, though we do the error check on attribute access */
+  /* TODO - make flags optional */
+  BMO_op_init(bm, &bmop, BMO_FLAG_DEFAULTS, self->opname);
+
+  if (kw && PyDict_Size(kw) > 0) {
+    /* setup properties, see bpy_rna.c: pyrna_py_to_prop()
+     * which shares this logic for parsing properties */
+
+    PyObject *key, *value;
+    Py_ssize_t pos = 0;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+      const char *slot_name = _PyUnicode_AsString(key);
+      BMOpSlot *slot;
+
+      if (!BMO_slot_exists(bmop.slots_in, slot_name)) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s: keyword \"%.200s\" is invalid for this operator",
+                     self->opname,
+                     slot_name);
+        BMO_op_finish(bm, &bmop);
+        return NULL;
+      }
+
+      slot = BMO_slot_get(bmop.slots_in, slot_name);
+
+      /* now assign the value */
+      if (bpy_slot_from_py(bm, &bmop, slot, value, self->opname, slot_name) == -1) {
+        BMO_op_finish(bm, &bmop);
+        return NULL;
+      }
+    }
+  }
+
+  BMO_op_exec(bm, &bmop);
+
+  /* from here until the end of the function, no returns, just set 'ret' */
+  if (UNLIKELY(bpy_bm_op_as_py_error(bm) == -1)) {
+    ret = NULL; /* exception raised above */
+  }
+  else if (bmop.slots_out[0].slot_name == NULL) {
+    ret = Py_INCREF_RET(Py_None);
+  }
+  else {
+    /* build return value */
+    int i;
+    ret = PyDict_New();
+
+    for (i = 0; bmop.slots_out[i].slot_name; i++) {
+      // BMOpDefine *op_def = opdefines[bmop.type];
+      // BMOSlotType *slot_type = op_def->slot_types_out[i];
+      BMOpSlot *slot = &bmop.slots_out[i];
+      PyObject *item;
+
+      /* this function doesn't throw exceptions */
+      item = bpy_slot_to_py(bm, slot);
+      if (item == NULL) {
+        item = Py_INCREF_RET(Py_None);
+      }
 
 #if 1
-			/* temp code, strip off '.out' while we keep this convention */
-			{
-				char slot_name_strip[MAX_SLOTNAME];
-				const char *ch = strchr(slot->slot_name, '.');  /* can't fail! */
-				int tot = ch - slot->slot_name;
-				BLI_assert(ch != NULL);
-				memcpy(slot_name_strip, slot->slot_name, tot);
-				slot_name_strip[tot] = '\0';
-				PyDict_SetItemString(ret, slot_name_strip, item);
-			}
+      /* temp code, strip off '.out' while we keep this convention */
+      {
+        char slot_name_strip[MAX_SLOTNAME];
+        const char *ch = strchr(slot->slot_name, '.'); /* can't fail! */
+        int tot = ch - slot->slot_name;
+        BLI_assert(ch != NULL);
+        memcpy(slot_name_strip, slot->slot_name, tot);
+        slot_name_strip[tot] = '\0';
+        PyDict_SetItemString(ret, slot_name_strip, item);
+      }
 #else
-			PyDict_SetItemString(ret, slot->slot_name, item);
+      PyDict_SetItemString(ret, slot->slot_name, item);
 #endif
-			Py_DECREF(item);
-		}
-	}
+      Py_DECREF(item);
+    }
+  }
 
-	BMO_op_finish(bm, &bmop);
-	return ret;
+  BMO_op_finish(bm, &bmop);
+  return ret;
 }