code cleanup: make bmesh operator names more consistant since python has access to these as input arguments and return values.

all output values currently have ".out" suffix, this may go in the future, but for now it makes it clear in C code what are inputs and outputs.

35 files changed, 673 insertions, 553 deletions

diff --git a/source/blender/bmesh/intern/bmesh_opdefines.c b/source/blender/bmesh/intern/bmesh_opdefines.c
index 539682454ea..ec07eb5d9f7 100644
--- a/source/blender/bmesh/intern/bmesh_opdefines.c
+++ b/source/blender/bmesh/intern/bmesh_opdefines.c
@@ -47,9 +47,9 @@
  * "in" (e.g. edgefacein).  for three-type slots, use geom.
  *
  * for output slots, for single-type geometry slots, use the type name plus "out",
- * (e.g. vertout), for double-type slots, use the two type names plus "out",
- * (e.g. vertfaceout), for three-type slots, use geom.  note that you can also
- * use more esohteric names (e.g. skirtout) so long as the comment next to the
+ * (e.g. verts.out), for double-type slots, use the two type names plus "out",
+ * (e.g. vertfaces.out), for three-type slots, use geom.  note that you can also
+ * use more esohteric names (e.g. geom_skirt.out) so long as the comment next to the
  * slot definition tells you what types of elements are in it.
  *
  */
@@ -82,7 +82,7 @@
  * would be extracted from comments
  * next to them, e.g.
  *
- * {BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, //output slot, boundary region
+ * {BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, //output slot, boundary region
  *
  * the doc generator would automatically detect the presence of "output slot"
  * and flag the slot as an output.  the same happens for "input slot".  also
@@ -99,15 +99,16 @@
  */
 static BMOpDefine bmo_smooth_vert_def = {
 	"smooth_vert",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertices */
-	 {BMO_OP_SLOT_BOOL, "mirror_clip_x"}, /* set vertices close to the x axis before the operation to 0 */
-	 {BMO_OP_SLOT_BOOL, "mirror_clip_y"}, /* set vertices close to the y axis before the operation to 0 */
-	 {BMO_OP_SLOT_BOOL, "mirror_clip_z"}, /* set vertices close to the z axis before the operation to 0 */
-	 {BMO_OP_SLOT_FLT, "clipdist"}, /* clipping threshod for the above three slots */
-	 {BMO_OP_SLOT_BOOL, "use_axis_x"}, /* smooth vertices along X axis */
-	 {BMO_OP_SLOT_BOOL, "use_axis_y"}, /* smooth vertices along Y axis */
-	 {BMO_OP_SLOT_BOOL, "use_axis_z"}, /* smooth vertices along Z axis */
-	{0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
+	 {BMO_OP_SLOT_BOOL, "mirror_clip_x"},   /* set vertices close to the x axis before the operation to 0 */
+	 {BMO_OP_SLOT_BOOL, "mirror_clip_y"},   /* set vertices close to the y axis before the operation to 0 */
+	 {BMO_OP_SLOT_BOOL, "mirror_clip_z"},   /* set vertices close to the z axis before the operation to 0 */
+	 {BMO_OP_SLOT_FLT,  "clip_dist"},       /* clipping threshod for the above three slots */
+	 {BMO_OP_SLOT_BOOL, "use_axis_x"},      /* smooth vertices along X axis */
+	 {BMO_OP_SLOT_BOOL, "use_axis_y"},      /* smooth vertices along Y axis */
+	 {BMO_OP_SLOT_BOOL, "use_axis_z"},      /* smooth vertices along Z axis */
+	{0},
 	},
 	{{0}},  /* no output */
 	bmo_smooth_vert_exec,
@@ -121,14 +122,15 @@ static BMOpDefine bmo_smooth_vert_def = {
  */
 static BMOpDefine bmo_smooth_laplacian_vert_def = {
 	"smooth_laplacian_vert",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, //input vertices
-	 {BMO_OP_SLOT_FLT, "lambda"}, //lambda param
-	 {BMO_OP_SLOT_FLT, "lambda_border"}, //lambda param in border
-	 {BMO_OP_SLOT_BOOL, "use_x"}, //Smooth object along X axis
-	 {BMO_OP_SLOT_BOOL, "use_y"}, //Smooth object along Y axis
-	 {BMO_OP_SLOT_BOOL, "use_z"}, //Smooth object along Z axis
-	 {BMO_OP_SLOT_BOOL, "volume_preservation"}, //Apply volume preservation after smooth
-	{0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
+	 {BMO_OP_SLOT_FLT, "lambda"},           /* lambda param */
+	 {BMO_OP_SLOT_FLT, "lambda_border"},    /* lambda param in border */
+	 {BMO_OP_SLOT_BOOL, "use_x"},           /* Smooth object along X axis */
+	 {BMO_OP_SLOT_BOOL, "use_y"},           /* Smooth object along Y axis */
+	 {BMO_OP_SLOT_BOOL, "use_z"},           /* Smooth object along Z axis */
+	 {BMO_OP_SLOT_BOOL, "preserve_volume"}, /* Apply volume preservation after smooth */
+	{0},
 	},
 	{{0}},  /* no output */
 	bmo_smooth_laplacian_vert_exec,
@@ -143,9 +145,10 @@ static BMOpDefine bmo_smooth_laplacian_vert_def = {
 
 static BMOpDefine bmo_recalc_face_normals_def = {
 	"recalc_face_normals",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},
-	 {BMO_OP_SLOT_BOOL, "do_flip"}, /* internal flag, used by bmesh_rationalize_normals */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_BOOL, "use_flip"},        /* internal flag, used by bmesh_rationalize_normals */
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_recalc_face_normals_exec,
@@ -157,20 +160,22 @@ static BMOpDefine bmo_recalc_face_normals_def = {
  *
  * used to implement the select more/less tools.
  * this puts some geometry surrounding regions of
- * geometry in geom into geomout.
+ * geometry in geom into geom.out.
  *
- * if usefaces is 0 then geomout spits out verts and edges,
+ * if usefaces is 0 then geom.out spits out verts and edges,
  * otherwise it spits out faces.
  */
 static BMOpDefine bmo_region_extend_def = {
 	"region_extend",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input geometry */
-	 {BMO_OP_SLOT_BOOL, "constrict"}, /* find boundary inside the regions, not outside. */
-	 {BMO_OP_SLOT_BOOL, "use_faces"}, /* extend from faces instead of edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* input geometry */
+	 {BMO_OP_SLOT_BOOL, "use_constrict"},   /* find boundary inside the regions, not outside. */
+	 {BMO_OP_SLOT_BOOL, "use_faces"},       /* extend from faces instead of edges */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, /* output slot, computed boundary geometry. */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* output slot, computed boundary geometry. */
+	 {0},
 	},
 	bmo_region_extend_exec,
 	0
@@ -184,12 +189,14 @@ static BMOpDefine bmo_region_extend_def = {
  */
 static BMOpDefine bmo_rotate_edges_def = {
 	"rotate_edges",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
-	 {BMO_OP_SLOT_BOOL, "ccw"}, /* rotate edge counter-clockwise if true, othewise clockwise */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
+	 {BMO_OP_SLOT_BOOL, "use_ccw"},         /* rotate edge counter-clockwise if true, othewise clockwise */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"}, /* newly spun edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"}, /* newly spun edges */
+	 {0},
 	},
 	bmo_rotate_edges_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -203,8 +210,9 @@ static BMOpDefine bmo_rotate_edges_def = {
  */
 static BMOpDefine bmo_reverse_faces_def = {
 	"reverse_faces",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_reverse_faces_exec,
@@ -219,12 +227,14 @@ static BMOpDefine bmo_reverse_faces_def = {
  */
 static BMOpDefine bmo_bisect_edges_def = {
 	"bisect_edges",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
-	 {BMO_OP_SLOT_INT, "numcuts"}, /* number of cuts */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_INT, "cuts"}, /* number of cuts */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "splitout"}, /* newly created vertices and edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom_split.out"}, /* newly created vertices and edges */
+	 {0},
 	},
 	bmo_bisect_edges_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -234,22 +244,24 @@ static BMOpDefine bmo_bisect_edges_def = {
  * Mirror
  *
  * Mirrors geometry along an axis.  The resulting geometry is welded on using
- * mergedist.  Pairs of original/mirrored vertices are welded using the mergedist
+ * merge_dist.  Pairs of original/mirrored vertices are welded using the merge_dist
  * parameter (which defines the minimum distance for welding to happen).
  */
 
 static BMOpDefine bmo_mirror_def = {
 	"mirror",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input geometry */
-	 {BMO_OP_SLOT_MAT, "mat"}, /* matrix defining the mirror transformation */
-	 {BMO_OP_SLOT_FLT, "mergedist"}, /* maximum distance for merging.  does no merging if 0. */
-	 {BMO_OP_SLOT_INT,         "axis"}, /* the axis to use, 0, 1, or 2 for x, y, z */
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* input geometry */
+	 {BMO_OP_SLOT_MAT,         "mat"},      /* matrix defining the mirror transformation */
+	 {BMO_OP_SLOT_FLT, "merge_dist"},       /* maximum distance for merging.  does no merging if 0. */
+	 {BMO_OP_SLOT_INT,         "axis"},     /* the axis to use, 0, 1, or 2 for x, y, z */
 	 {BMO_OP_SLOT_BOOL,        "mirror_u"}, /* mirror UVs across the u axis */
 	 {BMO_OP_SLOT_BOOL,        "mirror_v"}, /* mirror UVs across the v axis */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "newout"}, /* output geometry, mirrored */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* output geometry, mirrored */
+	 {0},
 	},
 	bmo_mirror_exec,
 	0,
@@ -266,13 +278,15 @@ static BMOpDefine bmo_mirror_def = {
  */
 static BMOpDefine bmo_find_doubles_def = {
 	"find_doubles",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertices */
 	 {BMO_OP_SLOT_ELEMENT_BUF, "keep_verts"}, /* list of verts to keep */
 	 {BMO_OP_SLOT_FLT,         "dist"}, /* minimum distance */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_MAPPING, "targetmapout"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_MAPPING, "targetmap.out"},
+	 {0},
 	},
 	bmo_find_doubles_exec,
 	0,
@@ -286,9 +300,10 @@ static BMOpDefine bmo_find_doubles_def = {
  */
 static BMOpDefine bmo_remove_doubles_def = {
 	"remove_doubles",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input verts */
 	 {BMO_OP_SLOT_FLT,         "dist"}, /* minimum distance */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_remove_doubles_exec,
@@ -304,9 +319,10 @@ static BMOpDefine bmo_remove_doubles_def = {
  */
 static BMOpDefine bmo_automerge_def = {
 	"automerge",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input verts */
 	 {BMO_OP_SLOT_FLT,         "dist"}, /* minimum distance */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_automerge_exec,
@@ -320,8 +336,9 @@ static BMOpDefine bmo_automerge_def = {
  */
 static BMOpDefine bmo_collapse_def = {
 	"collapse",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edge */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_collapse_exec,
@@ -336,9 +353,10 @@ static BMOpDefine bmo_collapse_def = {
  */
 static BMOpDefine bmo_pointmerge_facedata_def = {
 	"pointmerge_facedata",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertice */
-	 {BMO_OP_SLOT_ELEMENT_BUF, "snapv"}, /* snap verte */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
+	 {BMO_OP_SLOT_ELEMENT_BUF, "snapv"},    /* snap vertex */
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_pointmerge_facedata_exec,
@@ -354,8 +372,9 @@ static BMOpDefine bmo_pointmerge_facedata_def = {
  */
 static BMOpDefine bmo_average_vert_facedata_def = {
 	"average_vert_facedata",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertice */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_average_vert_facedata_exec,
@@ -369,9 +388,10 @@ static BMOpDefine bmo_average_vert_facedata_def = {
  */
 static BMOpDefine bmo_pointmerge_def = {
 	"pointmerge",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertice */
 	 {BMO_OP_SLOT_VEC,         "merge_co"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_pointmerge_exec,
@@ -385,8 +405,9 @@ static BMOpDefine bmo_pointmerge_def = {
  */
 static BMOpDefine bmo_collapse_uvs_def = {
 	"collapse_uvs",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edge */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_collapse_uvs_exec,
@@ -402,8 +423,9 @@ static BMOpDefine bmo_collapse_uvs_def = {
  */
 static BMOpDefine bmo_weld_verts_def = {
 	"weld_verts",
+	/* slots_in */
 	{{BMO_OP_SLOT_MAPPING, "targetmap"}, /* maps welded vertices to verts they should weld to */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_weld_verts_exec,
@@ -418,11 +440,13 @@ static BMOpDefine bmo_weld_verts_def = {
  */
 static BMOpDefine bmo_create_vert_def = {
 	"create_vert",
+	/* slots_in */
 	{{BMO_OP_SLOT_VEC, "co"},  /* the coordinate of the new vert */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "newvertout"},  /* the new vert */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "vert.out"},  /* the new vert */
+	 {0},
 	},
 	bmo_create_vert_exec,
 	0,
@@ -436,16 +460,18 @@ static BMOpDefine bmo_create_vert_def = {
  */
 static BMOpDefine bmo_join_triangles_def = {
 	"join_triangles",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input geometry. */
 	 {BMO_OP_SLOT_BOOL, "cmp_sharp"},
 	 {BMO_OP_SLOT_BOOL, "cmp_uvs"},
 	 {BMO_OP_SLOT_BOOL, "cmp_vcols"},
 	 {BMO_OP_SLOT_BOOL, "cmp_materials"},
 	 {BMO_OP_SLOT_FLT, "limit"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faceout"},  /* joined faces */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},  /* joined faces */
+	 {0},
 	},
 	bmo_join_triangles_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES,
@@ -464,15 +490,17 @@ static BMOpDefine bmo_join_triangles_def = {
  */
 static BMOpDefine bmo_contextual_create_def = {
 	"contextual_create",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input geometry. */
-	 {BMO_OP_SLOT_INT,         "mat_nr"},      /* material to use */
-	 {BMO_OP_SLOT_BOOL,        "use_smooth"},  /* smooth to use */
-	 {0} /* null-terminating sentinel */,
-	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faceout"},     /* newly-made face(s) */
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* input geometry. */
+	 {BMO_OP_SLOT_INT,         "mat_nr"},   /* material to use */
+	 {BMO_OP_SLOT_BOOL,        "use_smooth"}, /* smooth to use */
+	 {0},
+	},
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* newly-made face(s) */
 	/* note, this is for stand-alone edges only, not edges which are apart of newly created faces */
-	 {BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},     /* newly-made edge(s) */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_ELEMENT_BUF, "edges.out"}, /* newly-made edge(s) */
+	 {0},
 	},
 	bmo_contextual_create_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES,
@@ -483,13 +511,15 @@ static BMOpDefine bmo_contextual_create_def = {
  */
 static BMOpDefine bmo_bridge_loops_def = {
 	"bridge_loops",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edge */
 	 {BMO_OP_SLOT_BOOL,        "use_merge"},
 	 {BMO_OP_SLOT_FLT,         "merge_factor"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, /* new faces */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* new faces */
+	 {0},
 	},
 	bmo_bridge_loops_exec,
 	0,
@@ -497,18 +527,20 @@ static BMOpDefine bmo_bridge_loops_def = {
 
 static BMOpDefine bmo_edgenet_fill_def = {
 	"edgenet_fill",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edge */
 	 {BMO_OP_SLOT_MAPPING,     "restrict"}, /* restricts edges to groups.  maps edges to integer */
 	 {BMO_OP_SLOT_BOOL,        "use_restrict"},
 	 {BMO_OP_SLOT_BOOL,        "use_fill_check"},
-	 {BMO_OP_SLOT_ELEMENT_BUF, "excludefaces"}, /* list of faces to ignore for manifold check */
+	 {BMO_OP_SLOT_ELEMENT_BUF, "exclude_faces"}, /* list of faces to ignore for manifold check */
 	 {BMO_OP_SLOT_INT,         "mat_nr"},      /* material to use */
 	 {BMO_OP_SLOT_BOOL,        "use_smooth"},  /* material to use */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_MAPPING,     "face_groupmap_out"}, /* maps new faces to the group numbers they came fro */
-	 {BMO_OP_SLOT_ELEMENT_BUF, "faceout"},     /* new face */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_MAPPING,     "face_groupmap.out"}, /* maps new faces to the group numbers they came from */
+	 {BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},     /* new face */
+	 {0},
 	},
 	bmo_edgenet_fill_exec,
 	0,
@@ -526,11 +558,13 @@ static BMOpDefine bmo_edgenet_fill_def = {
  */
 static BMOpDefine bmo_edgenet_prepare_def = {
 	"edgenet_prepare",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},  /* new edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},  /* new edges */
+	 {0},
 	},
 	bmo_edgenet_prepare,
 	0,
@@ -544,10 +578,11 @@ static BMOpDefine bmo_edgenet_prepare_def = {
  */
 static BMOpDefine bmo_rotate_def = {
 	"rotate",
+	/* slots_in */
 	{{BMO_OP_SLOT_VEC, "cent"},  /* center of rotation */
 	 {BMO_OP_SLOT_MAT, "mat"},   /* matrix defining rotation */
 	 {BMO_OP_SLOT_ELEMENT_BUF, "verts"},  /* input vertices */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_rotate_exec,
@@ -562,9 +597,10 @@ static BMOpDefine bmo_rotate_def = {
  */
 static BMOpDefine bmo_translate_def = {
 	"translate",
+	/* slots_in */
 	{{BMO_OP_SLOT_VEC, "vec"},  /* translation offset */
 	 {BMO_OP_SLOT_ELEMENT_BUF, "verts"},  /* input vertices */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_translate_exec,
@@ -578,9 +614,10 @@ static BMOpDefine bmo_translate_def = {
  */
 static BMOpDefine bmo_scale_def = {
 	"scale",
+	/* slots_in */
 	{{BMO_OP_SLOT_VEC, "vec"},  /* scale factor */
 	 {BMO_OP_SLOT_ELEMENT_BUF, "verts"},  /* input vertices */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_scale_exec,
@@ -596,9 +633,10 @@ static BMOpDefine bmo_scale_def = {
  */
 static BMOpDefine bmo_transform_def = {
 	"transform",
+	/* slots_in */
 	{{BMO_OP_SLOT_MAT, "mat"},  /* transform matrix */
 	 {BMO_OP_SLOT_ELEMENT_BUF, "verts"},  /* input vertices */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_transform_exec,
@@ -613,9 +651,10 @@ static BMOpDefine bmo_transform_def = {
  */
 static BMOpDefine bmo_object_load_bmesh_def = {
 	"object_load_bmesh",
+	/* slots_in */
 	{{BMO_OP_SLOT_PTR, "scene"},
 	 {BMO_OP_SLOT_PTR, "object"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_object_load_bmesh_exec,
@@ -630,10 +669,11 @@ static BMOpDefine bmo_object_load_bmesh_def = {
  */
 static BMOpDefine bmo_bmesh_to_mesh_def = {
 	"bmesh_to_mesh",
+	/* slots_in */
 	{{BMO_OP_SLOT_PTR, "mesh"},    /* pointer to a mesh structure to fill in */
 	 {BMO_OP_SLOT_PTR, "object"},  /* pointer to an object structure */
-	 {BMO_OP_SLOT_BOOL, "notessellation"},  /* don't calculate mfaces */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_BOOL, "skip_tessface"},  /* don't calculate mfaces */
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_bmesh_to_mesh_exec,
@@ -648,10 +688,11 @@ static BMOpDefine bmo_bmesh_to_mesh_def = {
  */
 static BMOpDefine bmo_mesh_to_bmesh_def = {
 	"mesh_to_bmesh",
+	/* slots_in */
 	{{BMO_OP_SLOT_PTR, "mesh"},    /* pointer to a Mesh structure */
 	 {BMO_OP_SLOT_PTR, "object"},  /* pointer to an Object structure */
-	 {BMO_OP_SLOT_BOOL, "set_shapekey"},  /* load active shapekey coordinates into verts */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_BOOL, "use_shapekey"},  /* load active shapekey coordinates into verts */
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_mesh_to_bmesh_exec,
@@ -665,12 +706,14 @@ static BMOpDefine bmo_mesh_to_bmesh_def = {
  */
 static BMOpDefine bmo_extrude_discrete_faces_def = {
 	"extrude_discrete_faces",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},     /* input faces */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faceout"},   /* output faces */
-	 {BMO_OP_SLOT_ELEMENT_BUF, "skirtout"},  /* output skirt geometry, faces and edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},   /* output faces */
+	 {BMO_OP_SLOT_ELEMENT_BUF, "geom_skirt.out"},  /* output skirt geometry, faces and edges */
+	 {0},
 	},
 	bmo_extrude_discrete_faces_exec,
 	0
@@ -684,11 +727,13 @@ static BMOpDefine bmo_extrude_discrete_faces_def = {
  */
 static BMOpDefine bmo_extrude_edge_only_def = {
 	"extrude_edge_only",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input vertices */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},  /* output geometry */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},  /* output geometry */
+	 {0},
 	},
 	bmo_extrude_edge_only_exec,
 	0
@@ -701,12 +746,14 @@ static BMOpDefine bmo_extrude_edge_only_def = {
  */
 static BMOpDefine bmo_extrude_vert_indiv_def = {
 	"extrude_vert_indiv",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},  /* output wire edges */
-	 {BMO_OP_SLOT_ELEMENT_BUF, "vertout"},  /* output vertices */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},  /* output wire edges */
+	 {BMO_OP_SLOT_ELEMENT_BUF, "verts.out"},  /* output vertices */
+	 {0},
 	},
 	bmo_extrude_vert_indiv_exec,
 	0
@@ -714,11 +761,13 @@ static BMOpDefine bmo_extrude_vert_indiv_def = {
 
 static BMOpDefine bmo_connect_verts_def = {
 	"connect_verts",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},
+	 {0},
 	},
 	bmo_connect_verts_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -726,13 +775,15 @@ static BMOpDefine bmo_connect_verts_def = {
 
 static BMOpDefine bmo_extrude_face_region_def = {
 	"extrude_face_region",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edgefacein"},
-	 {BMO_OP_SLOT_MAPPING, "exclude"},
-	 {BMO_OP_SLOT_BOOL, "alwayskeeporig"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* edges and faces */
+	 {BMO_OP_SLOT_MAPPING, "edges_exclude"},
+	 {BMO_OP_SLOT_BOOL, "use_keep_orig"},   /* keep original geometry */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+	 {0},
 	},
 	bmo_extrude_face_region_exec,
 	0
@@ -740,8 +791,9 @@ static BMOpDefine bmo_extrude_face_region_def = {
 
 static BMOpDefine bmo_dissolve_verts_def = {
 	"dissolve_verts",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_dissolve_verts_exec,
@@ -750,12 +802,14 @@ static BMOpDefine bmo_dissolve_verts_def = {
 
 static BMOpDefine bmo_dissolve_edges_def = {
 	"dissolve_edges",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"},
 	 {BMO_OP_SLOT_BOOL, "use_verts"},  /* dissolve verts left between only 2 edges. */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "regionout"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "region.out"},
+	 {0},
 	},
 	bmo_dissolve_edges_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -763,11 +817,13 @@ static BMOpDefine bmo_dissolve_edges_def = {
 
 static BMOpDefine bmo_dissolve_edge_loop_def = {
 	"dissolve_edge_loop",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "regionout"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "region.out"},
+	 {0},
 	},
 	bmo_dissolve_edgeloop_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -775,12 +831,14 @@ static BMOpDefine bmo_dissolve_edge_loop_def = {
 
 static BMOpDefine bmo_dissolve_faces_def = {
 	"dissolve_faces",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},
 	 {BMO_OP_SLOT_BOOL, "use_verts"},  /* dissolve verts left between only 2 edges. */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "regionout"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "region.out"},
+	 {0},
 	},
 	bmo_dissolve_faces_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -788,11 +846,12 @@ static BMOpDefine bmo_dissolve_faces_def = {
 
 static BMOpDefine bmo_dissolve_limit_def = {
 	"dissolve_limit",
+	/* slots_in */
 	{{BMO_OP_SLOT_FLT, "angle_limit"}, /* total rotation angle (degrees) */
 	 {BMO_OP_SLOT_BOOL, "use_dissolve_boundaries"},
 	 {BMO_OP_SLOT_ELEMENT_BUF, "verts"},
 	 {BMO_OP_SLOT_ELEMENT_BUF, "edges"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_dissolve_limit_exec,
@@ -801,14 +860,16 @@ static BMOpDefine bmo_dissolve_limit_def = {
 
 static BMOpDefine bmo_triangulate_def = {
 	"triangulate",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},
 	 {BMO_OP_SLOT_BOOL, "use_beauty"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},
-	 {BMO_OP_SLOT_ELEMENT_BUF, "faceout"},
-	 {BMO_OP_SLOT_MAPPING, "facemap_out"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},
+	 {BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},
+	 {BMO_OP_SLOT_MAPPING, "facemap.out"},
+	 {0},
 	},
 	bmo_triangulate_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -816,9 +877,10 @@ static BMOpDefine bmo_triangulate_def = {
 
 static BMOpDefine bmo_unsubdivide_def = {
 	"unsubdivide",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* input vertices */
 	 {BMO_OP_SLOT_INT, "iterations"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_unsubdivide_exec,
@@ -827,26 +889,28 @@ static BMOpDefine bmo_unsubdivide_def = {
 
 static BMOpDefine bmo_subdivide_edges_def = {
 	"subdivide_edges",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"},
 	 {BMO_OP_SLOT_FLT, "smooth"},
 	 {BMO_OP_SLOT_FLT, "fractal"},
 	 {BMO_OP_SLOT_FLT, "along_normal"},
-	 {BMO_OP_SLOT_INT, "numcuts"},
+	 {BMO_OP_SLOT_INT, "cuts"},
 	 {BMO_OP_SLOT_INT, "seed"},
 	 {BMO_OP_SLOT_MAPPING, "custompatterns"},
 	 {BMO_OP_SLOT_MAPPING, "edgepercents"},
 
-	 {BMO_OP_SLOT_INT,  "quadcornertype"}, /* quad corner type, see bmesh_operators.h */
+	 {BMO_OP_SLOT_INT,  "quad_corner_type"}, /* quad corner type, see bmesh_operators.h */
 	 {BMO_OP_SLOT_BOOL, "use_gridfill"},   /* fill in fully-selected faces with a grid */
 	 {BMO_OP_SLOT_BOOL, "use_singleedge"}, /* tessellate the case of one edge selected in a quad or triangle */
 	 {BMO_OP_SLOT_BOOL, "use_sphere"},     /* for making new primitives only */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
+	/* slots_out */
 	{/* these next three can have multiple types of elements in them */
-	 {BMO_OP_SLOT_ELEMENT_BUF, "innerout"},
-	 {BMO_OP_SLOT_ELEMENT_BUF, "splitout"},
-	 {BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, /* contains all output geometr */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_ELEMENT_BUF, "geom_inner.out"},
+	 {BMO_OP_SLOT_ELEMENT_BUF, "geom_split.out"},
+	 {BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* contains all output geometr */
+	 {0},
 	},
 	bmo_subdivide_edges_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -854,9 +918,10 @@ static BMOpDefine bmo_subdivide_edges_def = {
 
 static BMOpDefine bmo_delete_def = {
 	"delete",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
 	 {BMO_OP_SLOT_INT, "context"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_delete_exec,
@@ -865,18 +930,20 @@ static BMOpDefine bmo_delete_def = {
 
 static BMOpDefine bmo_duplicate_def = {
 	"duplicate",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
 	 {BMO_OP_SLOT_PTR, "dest"}, /* destination bmesh, if NULL will use current on */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "origout"},
-	 {BMO_OP_SLOT_ELEMENT_BUF, "newout"},
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom_orig.out"},
+	 {BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
 	/* facemap maps from source faces to dupe
 	 * faces, and from dupe faces to source faces */
-	 {BMO_OP_SLOT_MAPPING, "facemap_out"},
-	 {BMO_OP_SLOT_MAPPING, "boundarymap_out"},
-	 {BMO_OP_SLOT_MAPPING, "isovertmap_out"},
-	{0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_MAPPING, "facemap.out"},
+	 {BMO_OP_SLOT_MAPPING, "boundarymap.out"},
+	 {BMO_OP_SLOT_MAPPING, "isovertmap.out"},
+	{0},
 	},
 	bmo_duplicate_exec,
 	0
@@ -884,15 +951,17 @@ static BMOpDefine bmo_duplicate_def = {
 
 static BMOpDefine bmo_split_def = {
 	"split",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
-	 {BMO_OP_SLOT_PTR, "dest"}, /* destination bmesh, if NULL will use current on */
-	 {BMO_OP_SLOT_BOOL, "use_only_faces"}, /* when enabled. don't duplicate loose verts/edges */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_PTR, "dest"},             /* destination bmesh, if NULL will use current one */
+	 {BMO_OP_SLOT_BOOL, "use_only_faces"},  /* when enabled. don't duplicate loose verts/edges */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-	 {BMO_OP_SLOT_MAPPING, "boundarymap_out"},
-	 {BMO_OP_SLOT_MAPPING, "isovertmap_out"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+	 {BMO_OP_SLOT_MAPPING, "boundarymap.out"},
+	 {BMO_OP_SLOT_MAPPING, "isovertmap.out"},
+	 {0},
 	},
 	bmo_split_exec,
 	0
@@ -906,17 +975,19 @@ static BMOpDefine bmo_split_def = {
  */
 static BMOpDefine bmo_spin_def = {
 	"spin",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
-	 {BMO_OP_SLOT_VEC, "cent"}, /* rotation center */
-	 {BMO_OP_SLOT_VEC, "axis"}, /* rotation axis */
-	 {BMO_OP_SLOT_VEC, "dvec"}, /* translation delta per step */
-	 {BMO_OP_SLOT_FLT, "ang"}, /* total rotation angle (degrees) */
-	 {BMO_OP_SLOT_INT, "steps"}, /* number of steps */
-	 {BMO_OP_SLOT_BOOL, "do_dupli"}, /* duplicate or extrude? */
-	 {0} /* null-terminating sentinel */,
-	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "lastout"}, /* result of last step */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_VEC, "cent"},             /* rotation center */
+	 {BMO_OP_SLOT_VEC, "axis"},             /* rotation axis */
+	 {BMO_OP_SLOT_VEC, "dvec"},             /* translation delta per step */
+	 {BMO_OP_SLOT_FLT, "angle"},            /* total rotation angle (degrees) */
+	 {BMO_OP_SLOT_INT, "steps"},            /* number of steps */
+	 {BMO_OP_SLOT_BOOL, "use_duplicate"},   /* duplicate or extrude? */
+	 {0},
+	},
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom_last.out"}, /* result of last step */
+	 {0},
 	},
 	bmo_spin_exec,
 	0
@@ -930,14 +1001,16 @@ static BMOpDefine bmo_spin_def = {
  */
 static BMOpDefine bmo_similar_faces_def = {
 	"similar_faces",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
 	 {BMO_OP_SLOT_INT, "type"},             /* type of selection */
 	 {BMO_OP_SLOT_FLT, "thresh"},           /* threshold of selection */
 	 {BMO_OP_SLOT_INT, "compare"},          /* comparison method */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faceout"},  /* output faces */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"},  /* output faces */
+	 {0},
 	},
 	bmo_similar_faces_exec,
 	0
@@ -950,14 +1023,16 @@ static BMOpDefine bmo_similar_faces_def = {
  */
 static BMOpDefine bmo_similar_edges_def = {
 	"similar_edges",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
 	 {BMO_OP_SLOT_INT, "type"},             /* type of selection */
 	 {BMO_OP_SLOT_FLT, "thresh"},           /* threshold of selection */
 	 {BMO_OP_SLOT_INT, "compare"},          /* comparison method */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"},  /* output edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"},  /* output edges */
+	 {0},
 	},
 	bmo_similar_edges_exec,
 	0
@@ -970,14 +1045,16 @@ static BMOpDefine bmo_similar_edges_def = {
  */
 static BMOpDefine bmo_similar_verts_def = {
 	"similar_verts",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* input vertices */
 	 {BMO_OP_SLOT_INT, "type"},             /* type of selection */
 	 {BMO_OP_SLOT_FLT, "thresh"},           /* threshold of selection */
 	 {BMO_OP_SLOT_INT, "compare"},          /* comparison method */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"},  /* output vertices */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"},  /* output vertices */
+	 {0},
 	},
 	bmo_similar_verts_exec,
 	0
@@ -989,10 +1066,12 @@ static BMOpDefine bmo_similar_verts_def = {
  */
 static BMOpDefine bmo_rotate_uvs_def = {
 	"rotate_uvs",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-	 {BMO_OP_SLOT_INT, "dir"},			/* direction */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+	 {BMO_OP_SLOT_BOOL, "use_ccw"},         /* rotate counter-clockwise if true, othewise clockwise */
+	 {0},
 	},
+	/* slots_out */
 	{{0}},  /* no output */
 	bmo_rotate_uvs_exec,
 	0
@@ -1004,8 +1083,9 @@ static BMOpDefine bmo_rotate_uvs_def = {
  */
 static BMOpDefine bmo_reverse_uvs_def = {
 	"reverse_uvs",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_reverse_uvs_exec,
@@ -1018,9 +1098,10 @@ static BMOpDefine bmo_reverse_uvs_def = {
  */
 static BMOpDefine bmo_rotate_colors_def = {
 	"rotate_colors",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-	 {BMO_OP_SLOT_INT, "dir"},           /* direction */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+	 {BMO_OP_SLOT_BOOL, "use_ccw"},         /* rotate counter-clockwise if true, othewise clockwise */
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_rotate_colors_exec,
@@ -1033,8 +1114,9 @@ static BMOpDefine bmo_rotate_colors_def = {
  */
 static BMOpDefine bmo_reverse_colors_def = {
 	"reverse_colors",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
+	 {0},
 	},
 	{{0}},  /* no output */
 	bmo_reverse_colors_exec,
@@ -1048,13 +1130,15 @@ static BMOpDefine bmo_reverse_colors_def = {
  */
 static BMOpDefine bmo_shortest_path_def = {
 	"shortest_path",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "startv"}, /* start vertex */
-	 {BMO_OP_SLOT_ELEMENT_BUF, "endv"}, /* end vertex */
-	 {BMO_OP_SLOT_INT, "type"},			/* type of selection */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "startv"},   /* start vertex */
+	 {BMO_OP_SLOT_ELEMENT_BUF, "endv"},     /* end vertex */
+	 {BMO_OP_SLOT_INT, "type"},             /* type of selection */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output vertices */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output vertices */
+	 {0},
 	},
 	bmo_shortest_path_exec,
 	0
@@ -1067,14 +1151,16 @@ static BMOpDefine bmo_shortest_path_def = {
  */
 static BMOpDefine bmo_split_edges_def = {
 	"split_edges",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
 	 /* needed for vertex rip so we can rip only half an edge at a boundary wich would otherwise split off */
-	 {BMO_OP_SLOT_ELEMENT_BUF, "verts"}, /* optional tag verts, use to have greater control of splits */
+	 {BMO_OP_SLOT_ELEMENT_BUF, "verts"},    /* optional tag verts, use to have greater control of splits */
 	 {BMO_OP_SLOT_BOOL,        "use_verts"}, /* use 'verts' for splitting, else just find verts to split from edges */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edgeout"}, /* old output disconnected edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges.out"}, /* old output disconnected edges */
+	 {0},
 	},
 	bmo_split_edges_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -1087,14 +1173,16 @@ static BMOpDefine bmo_split_edges_def = {
  */
 static BMOpDefine bmo_create_grid_def = {
 	"create_grid",
-	{{BMO_OP_SLOT_INT,         "xsegments"}, /* number of x segments */
-	 {BMO_OP_SLOT_INT,         "ysegments"}, /* number of y segments */
-	 {BMO_OP_SLOT_FLT,         "size"}, /* size of the grid */
-	 {BMO_OP_SLOT_MAT,         "mat"}, /* matrix to multiply the new geometry with */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_INT,         "x_segments"}, /* number of x segments */
+	 {BMO_OP_SLOT_INT,         "y_segments"}, /* number of y segments */
+	 {BMO_OP_SLOT_FLT,         "size"},     /* size of the grid */
+	 {BMO_OP_SLOT_MAT,         "mat"},      /* matrix to multiply the new geometry with */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+	 {0},
 	},
 	bmo_create_grid_exec,
 	0,
@@ -1107,14 +1195,16 @@ static BMOpDefine bmo_create_grid_def = {
  */
 static BMOpDefine bmo_create_uvsphere_def = {
 	"create_uvsphere",
-	{{BMO_OP_SLOT_INT,         "segments"}, /* number of u segments */
-	 {BMO_OP_SLOT_INT,         "revolutions"}, /* number of v segment */
+	/* slots_in */
+	{{BMO_OP_SLOT_INT,         "u_segments"}, /* number of u segments */
+	 {BMO_OP_SLOT_INT,         "v_segments"}, /* number of v segment */
 	 {BMO_OP_SLOT_FLT,         "diameter"}, /* diameter */
-	 {BMO_OP_SLOT_MAT,         "mat"}, /* matrix to multiply the new geometry with-- */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_MAT,         "mat"}, /* matrix to multiply the new geometry with */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+	 {0},
 	},
 	bmo_create_uvsphere_exec,
 	0,
@@ -1127,13 +1217,15 @@ static BMOpDefine bmo_create_uvsphere_def = {
  */
 static BMOpDefine bmo_create_icosphere_def = {
 	"create_icosphere",
+	/* slots_in */
 	{{BMO_OP_SLOT_INT,         "subdivisions"}, /* how many times to recursively subdivide the sphere */
 	 {BMO_OP_SLOT_FLT,         "diameter"}, /* diameter */
 	 {BMO_OP_SLOT_MAT,         "mat"}, /* matrix to multiply the new geometry with */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+	 {0},
 	},
 	bmo_create_icosphere_exec,
 	0,
@@ -1146,11 +1238,13 @@ static BMOpDefine bmo_create_icosphere_def = {
  */
 static BMOpDefine bmo_create_monkey_def = {
 	"create_monkey",
-	{{BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with-- */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+	 {0},
 	},
 	bmo_create_monkey_exec,
 	0,
@@ -1163,17 +1257,19 @@ static BMOpDefine bmo_create_monkey_def = {
  */
 static BMOpDefine bmo_create_cone_def = {
 	"create_cone",
-	{{BMO_OP_SLOT_BOOL, "cap_ends"}, /* wheter or not to fill in the ends with faces */
-	 {BMO_OP_SLOT_BOOL, "cap_tris"}, /* fill ends with triangles instead of ngons */
+	/* slots_in */
+	{{BMO_OP_SLOT_BOOL, "cap_ends"},        /* wheter or not to fill in the ends with faces */
+	 {BMO_OP_SLOT_BOOL, "cap_tris"},        /* fill ends with triangles instead of ngons */
 	 {BMO_OP_SLOT_INT, "segments"},
-	 {BMO_OP_SLOT_FLT, "diameter1"}, /* diameter of one end */
-	 {BMO_OP_SLOT_FLT, "diameter2"}, /* diameter of the opposite */
-	 {BMO_OP_SLOT_FLT, "depth"}, /* distance between ends */
-	 {BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with-- */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_FLT, "diameter1"},        /* diameter of one end */
+	 {BMO_OP_SLOT_FLT, "diameter2"},        /* diameter of the opposite */
+	 {BMO_OP_SLOT_FLT, "depth"},            /* distance between ends */
+	 {BMO_OP_SLOT_MAT, "mat"},              /* matrix to multiply the new geometry with */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+	 {0},
 	},
 	bmo_create_cone_exec,
 	0,
@@ -1184,15 +1280,17 @@ static BMOpDefine bmo_create_cone_def = {
  */
 static BMOpDefine bmo_create_circle_def = {
 	"create_circle",
-	{{BMO_OP_SLOT_BOOL, "cap_ends"}, /* wheter or not to fill in the ends with faces */
-	 {BMO_OP_SLOT_BOOL, "cap_tris"}, /* fill ends with triangles instead of ngons */
+	/* slots_in */
+	{{BMO_OP_SLOT_BOOL, "cap_ends"},        /* wheter or not to fill in the ends with faces */
+	 {BMO_OP_SLOT_BOOL, "cap_tris"},        /* fill ends with triangles instead of ngons */
 	 {BMO_OP_SLOT_INT, "segments"},
-	 {BMO_OP_SLOT_FLT, "diameter"}, /* diameter of one end */
-	 {BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with-- */
-	 {0} /* null-terminating sentinel */,
+	 {BMO_OP_SLOT_FLT, "diameter"},         /* diameter of one end */
+	 {BMO_OP_SLOT_MAT, "mat"},              /* matrix to multiply the new geometry with */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+	 {0},
 	},
 	bmo_create_circle_exec,
 	0,
@@ -1205,12 +1303,14 @@ static BMOpDefine bmo_create_circle_def = {
  */
 static BMOpDefine bmo_create_cube_def = {
 	"create_cube",
-	{{BMO_OP_SLOT_FLT, "size"}, /* size of the cube */
-	 {BMO_OP_SLOT_MAT, "mat"}, /* matrix to multiply the new geometry with-- */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_FLT, "size"},             /* size of the cube */
+	 {BMO_OP_SLOT_MAT, "mat"},              /* matrix to multiply the new geometry with */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"}, /* output verts */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"}, /* output verts */
+	 {0},
 	},
 	bmo_create_cube_exec,
 	0,
@@ -1223,13 +1323,15 @@ static BMOpDefine bmo_create_cube_def = {
  */
 static BMOpDefine bmo_bevel_def = {
 	"bevel",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input edges and vertices */
-	 {BMO_OP_SLOT_FLT, "offset"}, /* amount to offset beveled edge */
-	 {BMO_OP_SLOT_INT, "segments"}, /* number of segments in bevel */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},     /* input edges and vertices */
+	 {BMO_OP_SLOT_FLT, "offset"},           /* amount to offset beveled edge */
+	 {BMO_OP_SLOT_INT, "segments"},         /* number of segments in bevel */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, /* output faces */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* output faces */
+	 {0},
 	},
 #if 0  /* old bevel*/
 	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"}, /* input edges and vertices */
@@ -1241,7 +1343,7 @@ static BMOpDefine bmo_bevel_def = {
 	                                  * modifier uses this. We could do this as another float setting */
 	 {BMO_OP_SLOT_INT, "lengthlayer"}, /* which PROP_FLT layer to us */
 	 {BMO_OP_SLOT_FLT, "percent"}, /* percentage to expand beveled edge */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
 #endif
 	bmo_bevel_exec,
@@ -1255,12 +1357,14 @@ static BMOpDefine bmo_bevel_def = {
  */
 static BMOpDefine bmo_beautify_fill_def = {
 	"beautify_fill",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"}, /* input faces */
 	 {BMO_OP_SLOT_ELEMENT_BUF, "constrain_edges"}, /* edges that can't be flipped */
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, /* new flipped faces and edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* new flipped faces and edges */
+	 {0},
 	},
 	bmo_beautify_fill_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -1273,11 +1377,13 @@ static BMOpDefine bmo_beautify_fill_def = {
  */
 static BMOpDefine bmo_triangle_fill_def = {
 	"triangle_fill",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"}, /* input edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "edges"},    /* input edges */
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geomout"}, /* new faces and edges */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"}, /* new faces and edges */
+	 {0},
 	},
 	bmo_triangle_fill_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -1290,12 +1396,14 @@ static BMOpDefine bmo_triangle_fill_def = {
  */
 static BMOpDefine bmo_solidify_def = {
 	"solidify",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "geom"},
 	 {BMO_OP_SLOT_FLT, "thickness"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+	 {0},
 	},
 	bmo_solidify_face_region_exec,
 	0
@@ -1308,17 +1416,19 @@ static BMOpDefine bmo_solidify_def = {
  */
 static BMOpDefine bmo_inset_def = {
 	"inset",
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},   /* input faces */
+	/* slots_in */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},    /* input faces */
 	 {BMO_OP_SLOT_BOOL, "use_boundary"},
 	 {BMO_OP_SLOT_BOOL, "use_even_offset"},
 	 {BMO_OP_SLOT_BOOL, "use_relative_offset"},
 	 {BMO_OP_SLOT_FLT, "thickness"},
 	 {BMO_OP_SLOT_FLT, "depth"},
 	 {BMO_OP_SLOT_BOOL, "use_outset"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, /* output faces */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* output faces */
+	 {0},
 	},
 	bmo_inset_exec,
 	0
@@ -1331,6 +1441,7 @@ static BMOpDefine bmo_inset_def = {
  */
 static BMOpDefine bmo_wireframe_def = {
 	"wireframe",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "faces"},   /* input faces */
 	 {BMO_OP_SLOT_BOOL, "use_boundary"},
 	 {BMO_OP_SLOT_BOOL, "use_even_offset"},
@@ -1338,10 +1449,11 @@ static BMOpDefine bmo_wireframe_def = {
 	 {BMO_OP_SLOT_FLT, "thickness"},
 	 {BMO_OP_SLOT_BOOL, "use_relative_offset"},
 	 {BMO_OP_SLOT_FLT, "depth"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "faceout"}, /* output faces */
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "faces.out"}, /* output faces */
+	 {0},
 	},
 	bmo_wireframe_exec,
 	0
@@ -1354,13 +1466,15 @@ static BMOpDefine bmo_wireframe_def = {
  */
 static BMOpDefine bmo_slide_vert_def = {
 	"slide_vert",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "vert"},
 	 {BMO_OP_SLOT_ELEMENT_BUF, "edge"},
 	 {BMO_OP_SLOT_FLT, "distance_t"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "vertout"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "verts.out"},
+	 {0},
 	},
 	bmo_slide_vert_exec,
 	BMO_OP_FLAG_UNTAN_MULTIRES
@@ -1375,7 +1489,7 @@ static BMOpDefine bmo_slide_vert_def = {
  * If 'use_existing_faces' is true, the hull will not output triangles
  * that are covered by a pre-existing face.
  *
- * All hull vertices, faces, and edges are added to 'geomout'. Any
+ * All hull vertices, faces, and edges are added to 'geom.out'. Any
  * input elements that end up inside the hull (i.e. are not used by an
  * output face) are added to the 'interior_geom' slot. The
  * 'unused_geom' slot will contain all interior geometry that is
@@ -1384,15 +1498,17 @@ static BMOpDefine bmo_slide_vert_def = {
  */
 static BMOpDefine bmo_convex_hull_def = {
 	"convex_hull",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "input"},
 	 {BMO_OP_SLOT_BOOL, "use_existing_faces"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-	 {BMO_OP_SLOT_ELEMENT_BUF, "interior_geom_out"},
-	 {BMO_OP_SLOT_ELEMENT_BUF, "unused_geom_out"},
-	 {BMO_OP_SLOT_ELEMENT_BUF, "holes_geom_out"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+	 {BMO_OP_SLOT_ELEMENT_BUF, "geom_interior.out"},
+	 {BMO_OP_SLOT_ELEMENT_BUF, "geom_unused.out"},
+	 {BMO_OP_SLOT_ELEMENT_BUF, "geom_holes.out"},
+	 {0},
 	},
 	bmo_convex_hull_exec,
 	0
@@ -1407,16 +1523,18 @@ static BMOpDefine bmo_convex_hull_def = {
  * the "direction" slot. The edges and faces that cross the plane of
  * symmetry are split as needed to enforce symmetry.
  *
- * All new vertices, edges, and faces are added to the "geomout" slot.
+ * All new vertices, edges, and faces are added to the "geom.out" slot.
  */
 static BMOpDefine bmo_symmetrize_def = {
 	"symmetrize",
+	/* slots_in */
 	{{BMO_OP_SLOT_ELEMENT_BUF, "input"},
 	 {BMO_OP_SLOT_INT, "direction"},
-	 {0} /* null-terminating sentinel */,
+	 {0},
 	},
-	{{BMO_OP_SLOT_ELEMENT_BUF, "geomout"},
-	 {0} /* null-terminating sentinel */,
+	/* slots_out */
+	{{BMO_OP_SLOT_ELEMENT_BUF, "geom.out"},
+	 {0},
 	},
 	bmo_symmetrize_exec,
 	0
diff --git a/source/blender/bmesh/intern/bmesh_operators.h b/source/blender/bmesh/intern/bmesh_operators.h
index 14da93302b9..b74d97c9bb5 100644
--- a/source/blender/bmesh/intern/bmesh_operators.h
+++ b/source/blender/bmesh/intern/bmesh_operators.h
@@ -88,11 +88,6 @@ enum {
 	OPUVC_AXIS_Y
 };
 
-enum {
-	DIRECTION_CW = 1,
-	DIRECTION_CCW
-};
-
 /* vertex path selection values */
 enum {
 	VPATH_SELECT_EDGE_LENGTH = 0,
diff --git a/source/blender/bmesh/operators/bmo_bevel.c b/source/blender/bmesh/operators/bmo_bevel.c
index f36856cece4..126d0f46119 100644
--- a/source/blender/bmesh/operators/bmo_bevel.c
+++ b/source/blender/bmesh/operators/bmo_bevel.c
@@ -56,6 +56,6 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
 
 		BM_mesh_bevel(bm, offset, seg);
 
-		BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faceout", BM_FACE, BM_ELEM_TAG);
+		BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faces.out", BM_FACE, BM_ELEM_TAG);
 	}
 }
diff --git a/source/blender/bmesh/operators/bmo_connect.c b/source/blender/bmesh/operators/bmo_connect.c
index 5c6f666620e..b7bb57bb19d 100644
--- a/source/blender/bmesh/operators/bmo_connect.c
+++ b/source/blender/bmesh/operators/bmo_connect.c
@@ -117,7 +117,7 @@ void bmo_connect_verts_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EDGE_OUT);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_OUT);
 
 	BLI_array_free(loops_split);
 	BLI_array_free(verts_pair);
@@ -523,7 +523,7 @@ void bmo_bridge_loops_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, FACE_OUT);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, FACE_OUT);
 
 cleanup:
 	BLI_array_free(ee1);
diff --git a/source/blender/bmesh/operators/bmo_create.c b/source/blender/bmesh/operators/bmo_create.c
index 52402ae2f86..e9a06631fac 100644
--- a/source/blender/bmesh/operators/bmo_create.c
+++ b/source/blender/bmesh/operators/bmo_create.c
@@ -911,7 +911,7 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
 	vdata = MEM_callocN(sizeof(VertData) * bm->totvert, "VertData");
 	
 	BMO_slot_buffer_flag_enable(bm, op->slots_in, "edges", BM_EDGE, EDGE_MARK);
-	BMO_slot_buffer_flag_enable(bm, op->slots_in, "excludefaces", BM_FACE, FACE_IGNORE);
+	BMO_slot_buffer_flag_enable(bm, op->slots_in, "exclude_faces", BM_FACE, FACE_IGNORE);
 	
 	BM_mesh_elem_index_ensure(bm, BM_VERT);
 
@@ -1055,7 +1055,7 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
 				}
 
 				if (use_restrict) {
-					BMO_slot_map_int_insert(op, op->slots_out, "face_groupmap_out", f, path->group);
+					BMO_slot_map_int_insert(op, op->slots_out, "face_groupmap.out", f, path->group);
 				}
 			}
 		}
@@ -1063,7 +1063,7 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op)
 		edge_free_path(pathbase, path);
 	}
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, FACE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, FACE_NEW);
 
 	BLI_array_free(edges);
 	BLI_array_free(verts);
@@ -1260,7 +1260,7 @@ void bmo_edgenet_prepare(BMesh *bm, BMOperator *op)
 		}
 	}
 	
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, ELE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, ELE_NEW);
 
 	BLI_array_free(edges1);
 	BLI_array_free(edges2);
@@ -1366,7 +1366,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
 	/* call edgenet prepare op so additional face creation cases wore */
 	BMO_op_initf(bm, &op2, op->flag, "edgenet_prepare edges=%fe", ELE_NEW);
 	BMO_op_exec(bm, &op2);
-	BMO_slot_buffer_flag_enable(bm, op2.slots_out, "edgeout", BM_EDGE, ELE_NEW);
+	BMO_slot_buffer_flag_enable(bm, op2.slots_out, "edges.out", BM_EDGE, ELE_NEW);
 	BMO_op_finish(bm, &op2);
 
 	BMO_op_initf(bm, &op2, op->flag,
@@ -1376,9 +1376,9 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
 	BMO_op_exec(bm, &op2);
 
 	/* return if edge net create did something */
-	if (BMO_slot_buffer_count(op2.slots_out, "faceout")) {
-		BMO_slot_copy(&op2, slots_out, "faceout",
-		              op,   slots_out, "faceout");
+	if (BMO_slot_buffer_count(op2.slots_out, "faces.out")) {
+		BMO_slot_copy(&op2, slots_out, "faces.out",
+		              op,   slots_out, "faces.out");
 		BMO_op_finish(bm, &op2);
 		return;
 	}
@@ -1390,9 +1390,9 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
 	BMO_op_exec(bm, &op2);
 	
 	/* if we dissolved anything, then return */
-	if (BMO_slot_buffer_count(op2.slots_out, "regionout")) {
-		BMO_slot_copy(&op2, slots_out, "regionout",
-		              op,   slots_out,  "faceout");
+	if (BMO_slot_buffer_count(op2.slots_out, "region.out")) {
+		BMO_slot_copy(&op2, slots_out, "region.out",
+		              op,   slots_out,  "faces.out");
 		BMO_op_finish(bm, &op2);
 		return;
 	}
@@ -1416,7 +1416,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
 		/* create edge */
 		e = BM_edge_create(bm, verts[0], verts[1], NULL, TRUE);
 		BMO_elem_flag_enable(bm, e, ELE_OUT);
-		BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, ELE_OUT);
+		BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, ELE_OUT);
 	}
 	else if (0) { /* nice feature but perhaps it should be a different tool? */
 
@@ -1462,7 +1462,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
 				}
 			}
 		}
-		BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, ELE_OUT);
+		BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, ELE_OUT);
 		/* done creating edges */
 	}
 	else if (amount > 2) {
diff --git a/source/blender/bmesh/operators/bmo_dissolve.c b/source/blender/bmesh/operators/bmo_dissolve.c
index 649aa8b214b..7c3bcd60daa 100644
--- a/source/blender/bmesh/operators/bmo_dissolve.c
+++ b/source/blender/bmesh/operators/bmo_dissolve.c
@@ -184,7 +184,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
 		goto cleanup;
 	}
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "regionout", BM_FACE, FACE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "region.out", BM_FACE, FACE_NEW);
 
 cleanup:
 	/* free/cleanup */
@@ -237,7 +237,7 @@ void bmo_dissolve_edgeloop_exec(BMesh *bm, BMOperator *op)
 	//BMO_op_initf(bm, &fop, "dissolve_faces faces=%ff", FACE_MARK);
 	//BMO_op_exec(bm, &fop);
 
-	//BMO_slot_copy(op, &fop, "regionout", "regionout");
+	//BMO_slot_copy(op, &fop, "region.out", "region.out");
 
 	//BMO_op_finish(bm, &fop);
 }
diff --git a/source/blender/bmesh/operators/bmo_dupe.c b/source/blender/bmesh/operators/bmo_dupe.c
index 5391341214b..f32ba4430b8 100644
--- a/source/blender/bmesh/operators/bmo_dupe.c
+++ b/source/blender/bmesh/operators/bmo_dupe.c
@@ -102,7 +102,7 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh,
 	if (rlen < 2) {
 		/* not sure what non-manifold cases of greater then three
 		 * radial should do. */
-		BMO_slot_map_ptr_insert(op, op->slots_out, "boundarymap_out",
+		BMO_slot_map_ptr_insert(op, op->slots_out, "boundarymap.out",
 		                        source_edge, target_edge);
 	}
 
@@ -154,8 +154,8 @@ static BMFace *copy_face(BMOperator *op, BMesh *source_mesh,
 	
 	/* create new face */
 	target_face = BM_face_create(target_mesh, vtar, edar, source_face->len, FALSE);
-	BMO_slot_map_ptr_insert(op, op->slots_out, "facemap_out", source_face, target_face);
-	BMO_slot_map_ptr_insert(op, op->slots_out, "facemap_out", target_face, source_face);
+	BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", source_face, target_face);
+	BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", target_face, source_face);
 
 	BM_elem_attrs_copy(source_mesh, target_mesh, source_face, target_face);
 
@@ -227,7 +227,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *source, BMesh *target)
 			}
 
 			if (isolated) {
-				BMO_slot_map_ptr_insert(op, op->slots_out, "isovertmap_out", v, v2);
+				BMO_slot_map_ptr_insert(op, op->slots_out, "isovertmap.out", v, v2);
 			}
 
 			BMO_elem_flag_enable(source, v, DUPE_DONE);
@@ -331,10 +331,10 @@ void bmo_duplicate_exec(BMesh *bm, BMOperator *op)
 	/* Output */
 	/* First copy the input buffers to output buffers - original data */
 	BMO_slot_copy(dupeop, slots_in,  "geom",
-	              dupeop, slots_out, "origout");
+	              dupeop, slots_out, "geom_orig.out");
 
 	/* Now alloc the new output buffers */
-	BMO_slot_buffer_from_enabled_flag(bm, dupeop, dupeop->slots_out, "newout", BM_ALL, DUPE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, dupeop, dupeop->slots_out, "geom.out", BM_ALL, DUPE_NEW);
 }
 
 #if 0 /* UNUSED */
@@ -435,14 +435,14 @@ void bmo_split_exec(BMesh *bm, BMOperator *op)
 	BMO_op_exec(bm, &delop);
 
 	/* now we make our outputs by copying the dupe output */
-	BMO_slot_copy(&dupeop, slots_out, "newout",
-	              splitop, slots_out, "geomout");
+	BMO_slot_copy(&dupeop, slots_out, "geom.out",
+	              splitop, slots_out, "geom.out");
 
-	BMO_slot_copy(&dupeop, slots_out, "boundarymap_out",
-	              splitop, slots_out, "boundarymap_out");
+	BMO_slot_copy(&dupeop, slots_out, "boundarymap.out",
+	              splitop, slots_out, "boundarymap.out");
 
-	BMO_slot_copy(&dupeop, slots_out, "isovertmap_out",
-	              splitop, slots_out, "isovertmap_out");
+	BMO_slot_copy(&dupeop, slots_out, "isovertmap.out",
+	              splitop, slots_out, "isovertmap.out");
 
 
 	/* cleanup */
@@ -487,33 +487,33 @@ void bmo_spin_exec(BMesh *bm, BMOperator *op)
 	BMO_slot_vec_get(op->slots_in, "dvec", dvec);
 	usedvec = !is_zero_v3(dvec);
 	steps    = BMO_slot_int_get(op->slots_in,   "steps");
-	phi      = BMO_slot_float_get(op->slots_in, "ang") * DEG2RADF(1.0f) / steps;
-	do_dupli = BMO_slot_bool_get(op->slots_in,  "do_dupli");
+	phi      = BMO_slot_float_get(op->slots_in, "angle") * DEG2RADF(1.0f) / steps;
+	do_dupli = BMO_slot_bool_get(op->slots_in,  "use_duplicate");
 
 	axis_angle_to_mat3(rmat, axis, phi);
 
 	BMO_slot_copy(op, slots_in,  "geom",
-	              op, slots_out, "lastout");
+	              op, slots_out, "geom_last.out");
 	for (a = 0; a < steps; a++) {
 		if (do_dupli) {
-			BMO_op_initf(bm, &dupop, op->flag, "duplicate geom=%S", op, "lastout");
+			BMO_op_initf(bm, &dupop, op->flag, "duplicate geom=%S", op, "geom_last.out");
 			BMO_op_exec(bm, &dupop);
 			BMO_op_callf(bm, op->flag,
 			             "rotate cent=%v mat=%m3 verts=%S",
-			             cent, rmat, &dupop, "newout");
-			BMO_slot_copy(&dupop, slots_out, "newout",
-			              op,     slots_out, "lastout");
+			             cent, rmat, &dupop, "geom.out");
+			BMO_slot_copy(&dupop, slots_out, "geom.out",
+			              op,     slots_out, "geom_last.out");
 			BMO_op_finish(bm, &dupop);
 		}
 		else {
-			BMO_op_initf(bm, &extop, op->flag, "extrude_face_region edgefacein=%S",
-			             op, "lastout");
+			BMO_op_initf(bm, &extop, op->flag, "extrude_face_region geom=%S",
+			             op, "geom_last.out");
 			BMO_op_exec(bm, &extop);
 			BMO_op_callf(bm, op->flag,
 			             "rotate cent=%v mat=%m3 verts=%S",
-			             cent, rmat, &extop, "geomout");
-			BMO_slot_copy(&extop, slots_out, "geomout",
-			              op,     slots_out, "lastout");
+			             cent, rmat, &extop, "geom.out");
+			BMO_slot_copy(&extop, slots_out, "geom.out",
+			              op,     slots_out, "geom_last.out");
 			BMO_op_finish(bm, &extop);
 		}
 
@@ -521,7 +521,7 @@ void bmo_spin_exec(BMesh *bm, BMOperator *op)
 			mul_m3_v3(rmat, dvec);
 			BMO_op_callf(bm, op->flag,
 			             "translate vec=%v verts=%S",
-			             dvec, op, "lastout");
+			             dvec, op, "geom_last.out");
 		}
 	}
 }
diff --git a/source/blender/bmesh/operators/bmo_edgesplit.c b/source/blender/bmesh/operators/bmo_edgesplit.c
index 90b3d0c890b..9e9e4b8c962 100644
--- a/source/blender/bmesh/operators/bmo_edgesplit.c
+++ b/source/blender/bmesh/operators/bmo_edgesplit.c
@@ -169,5 +169,5 @@ void bmo_split_edges_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 
-	BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "edgeout", BM_EDGE, BM_ELEM_INTERNAL_TAG);
+	BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "edges.out", BM_EDGE, BM_ELEM_INTERNAL_TAG);
 }
diff --git a/source/blender/bmesh/operators/bmo_extrude.c b/source/blender/bmesh/operators/bmo_extrude.c
index 65189e679bd..9ad0bd2c949 100644
--- a/source/blender/bmesh/operators/bmo_extrude.c
+++ b/source/blender/bmesh/operators/bmo_extrude.c
@@ -122,7 +122,7 @@ void bmo_extrude_discrete_faces_exec(BMesh *bm, BMOperator *op)
 	BMO_op_callf(bm, op->flag,
 	             "delete geom=%ff context=%i",
 	             EXT_DEL, DEL_ONLYFACES);
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, EXT_KEEP);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, EXT_KEEP);
 }
 
 /**
@@ -193,12 +193,12 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
 	/* disable root flag on all new skin nodes */
 	if (CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
 		BMVert *v;
-		BMO_ITER(v, &siter, dupeop.slots_out, "newout", BM_VERT) {
+		BMO_ITER(v, &siter, dupeop.slots_out, "geom.out", BM_VERT) {
 			bm_extrude_disable_skin_root(bm, v);
 		}
 	}
 
-	for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundarymap_out", 0); e; e = BMO_iter_step(&siter)) {
+	for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundarymap.out", 0); e; e = BMO_iter_step(&siter)) {
 		BMVert *f_verts[4];
 		e_new = *(BMEdge **)BMO_iter_map_value(&siter);
 
@@ -230,7 +230,7 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
 
 	BMO_op_finish(bm, &dupeop);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_ALL, EXT_KEEP);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_ALL, EXT_KEEP);
 }
 
 void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op)
@@ -251,8 +251,8 @@ void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op)
 		BMO_elem_flag_enable(bm, dupev, EXT_KEEP);
 	}
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, EXT_KEEP);
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EXT_KEEP);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, EXT_KEEP);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EXT_KEEP);
 }
 
 void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
@@ -268,11 +268,11 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
 	/* initialize our sub-operators */
 	BMO_op_init(bm, &dupeop, op->flag, "duplicate");
 	
-	BMO_slot_buffer_flag_enable(bm, op->slots_in, "edgefacein", BM_EDGE | BM_FACE, EXT_INPUT);
+	BMO_slot_buffer_flag_enable(bm, op->slots_in, "geom", BM_EDGE | BM_FACE, EXT_INPUT);
 	
 	/* if one flagged face is bordered by an un-flagged face, then we delete
 	 * original geometry unless caller explicitly asked to keep it. */
-	if (!BMO_slot_bool_get(op->slots_in, "alwayskeeporig")) {
+	if (!BMO_slot_bool_get(op->slots_in, "use_keep_orig")) {
 		BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
 
 			int edge_face_tot;
@@ -339,19 +339,19 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
 		             EXT_DEL, DEL_ONLYTAGGED);
 	}
 
-	BMO_slot_copy(op,      slots_in, "edgefacein",
+	BMO_slot_copy(op,      slots_in, "geom",
 	              &dupeop, slots_in, "geom");
 	BMO_op_exec(bm, &dupeop);
 
 	/* disable root flag on all new skin nodes */
 	if (CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
-		BMO_ITER(v, &siter, dupeop.slots_out, "newout", BM_VERT) {
+		BMO_ITER(v, &siter, dupeop.slots_out, "geom.out", BM_VERT) {
 			bm_extrude_disable_skin_root(bm, v);
 		}
 	}
 
 	if (bm->act_face && BMO_elem_flag_test(bm, bm->act_face, EXT_INPUT))
-		bm->act_face = BMO_slot_map_ptr_get(dupeop.slots_out, "facemap_out", bm->act_face);
+		bm->act_face = BMO_slot_map_ptr_get(dupeop.slots_out, "facemap.out", bm->act_face);
 
 	if (delorig) {
 		BMO_op_exec(bm, &delop);
@@ -366,14 +366,14 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 	
-	BMO_slot_copy(&dupeop, slots_out, "newout",
-	              op,      slots_out, "geomout");
+	BMO_slot_copy(&dupeop, slots_out, "geom.out",
+	              op,      slots_out, "geom.out");
 
-	for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundarymap_out", 0); e; e = BMO_iter_step(&siter)) {
+	for (e = BMO_iter_new(&siter, dupeop.slots_out, "boundarymap.out", 0); e; e = BMO_iter_step(&siter)) {
 		BMVert *f_verts[4];
 
 		/* this should always be wire, so this is mainly a speedup to avoid map lookup */
-		if (BM_edge_is_wire(e) && BMO_slot_map_contains(op->slots_in, "exclude", e)) {
+		if (BM_edge_is_wire(e) && BMO_slot_map_contains(op->slots_in, "edges_exclude", e)) {
 			BMVert *v1 = e->v1, *v2 = e->v2;
 
 			/* The original edge was excluded,
@@ -423,7 +423,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
 	}
 
 	/* link isolated vert */
-	for (v = BMO_iter_new(&siter, dupeop.slots_out, "isovertmap_out", 0); v; v = BMO_iter_step(&siter)) {
+	for (v = BMO_iter_new(&siter, dupeop.slots_out, "isovertmap.out", 0); v; v = BMO_iter_step(&siter)) {
 		v2 = *((void **)BMO_iter_map_value(&siter));
 		BM_edge_create(bm, v, v2, v->e, TRUE);
 	}
@@ -659,18 +659,18 @@ void bmo_solidify_face_region_exec(BMesh *bm, BMOperator *op)
 	BMO_op_finish(bm, &reverseop);
 
 	/* Extrude the region */
-	BMO_op_initf(bm, &extrudeop, op->flag, "extrude_face_region alwayskeeporig=%b", TRUE);
+	BMO_op_initf(bm, &extrudeop, op->flag, "extrude_face_region use_keep_orig=%b", TRUE);
 	BMO_slot_copy(op,         slots_in, "geom",
-	              &extrudeop, slots_in, "edgefacein");
+	              &extrudeop, slots_in, "geom");
 	BMO_op_exec(bm, &extrudeop);
 
 	/* Push the verts of the extruded faces inward to create thickness */
-	BMO_slot_buffer_flag_enable(bm, extrudeop.slots_out, "geomout", BM_FACE, FACE_MARK);
+	BMO_slot_buffer_flag_enable(bm, extrudeop.slots_out, "geom.out", BM_FACE, FACE_MARK);
 	calc_solidify_normals(bm);
 	solidify_add_thickness(bm, thickness);
 
-	BMO_slot_copy(&extrudeop, slots_out, "geomout",
-	              op,         slots_out, "geomout");
+	BMO_slot_copy(&extrudeop, slots_out, "geom.out",
+	              op,         slots_out, "geom.out");
 
 	BMO_op_finish(bm, &extrudeop);
 }
diff --git a/source/blender/bmesh/operators/bmo_hull.c b/source/blender/bmesh/operators/bmo_hull.c
index 7a8237b05d9..117f65ae4ea 100644
--- a/source/blender/bmesh/operators/bmo_hull.c
+++ b/source/blender/bmesh/operators/bmo_hull.c
@@ -139,17 +139,17 @@ static void hull_output_triangles(BMesh *bm, GHash *hull_triangles)
 				f = BM_face_create_quad_tri_v(bm, t->v, 3, example, TRUE);
 				BM_face_copy_shared(bm, f);
 			}
-			/* Mark face for 'geomout' slot and select */
+			/* Mark face for 'geom.out' slot and select */
 			BMO_elem_flag_enable(bm, f, HULL_FLAG_OUTPUT_GEOM);
 			BM_face_select_set(bm, f, TRUE);
 
-			/* Mark edges for 'geomout' slot */
+			/* Mark edges for 'geom.out' slot */
 			for (i = 0; i < 3; i++) {
 				BMO_elem_flag_enable(bm, edges[i], HULL_FLAG_OUTPUT_GEOM);
 			}
 		}
 		else {
-			/* Mark input edges for 'geomout' slot */
+			/* Mark input edges for 'geom.out' slot */
 			for (i = 0; i < 3; i++) {
 				const int next = (i == 2 ? 0 : i + 1);
 				BMEdge *e = BM_edge_exists(t->v[i], t->v[next]);
@@ -161,7 +161,7 @@ static void hull_output_triangles(BMesh *bm, GHash *hull_triangles)
 			}
 		}
 
-		/* Mark verts for 'geomout' slot */
+		/* Mark verts for 'geom.out' slot */
 		for (i = 0; i < 3; i++) {
 			BMO_elem_flag_enable(bm, t->v[i], HULL_FLAG_OUTPUT_GEOM);
 		}
@@ -603,22 +603,22 @@ void bmo_convex_hull_exec(BMesh *bm, BMOperator *op)
 
 	/* Output slot of input elements that ended up inside the hull
 	 * rather than part of it */
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "interior_geom_out",
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_interior.out",
 	                                  BM_ALL, HULL_FLAG_INTERIOR_ELE);
 
 	/* Output slot of input elements that ended up inside the hull and
 	 * are are unused by other geometry. */
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "unused_geom_out",
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_unused.out",
 	                                  BM_ALL, HULL_FLAG_DEL);
 
 	/* Output slot of faces and edges that were in the input and on
 	 * the hull (useful for cases like bridging where you want to
 	 * delete some input geometry) */
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "holes_geom_out",
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_holes.out",
 	                                  BM_ALL, HULL_FLAG_HOLE);
 
 	/* Output slot of all hull vertices, faces, and edges */
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout",
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out",
 	                                  BM_ALL, HULL_FLAG_OUTPUT_GEOM);
 }
 
diff --git a/source/blender/bmesh/operators/bmo_inset.c b/source/blender/bmesh/operators/bmo_inset.c
index 1da08fc68ee..bcfe8f9d414 100644
--- a/source/blender/bmesh/operators/bmo_inset.c
+++ b/source/blender/bmesh/operators/bmo_inset.c
@@ -481,7 +481,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
 	}
 
 	/* we could flag new edges/verts too, is it useful? */
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, ELE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, ELE_NEW);
 
 	/* cheap feature to add depth to the inset */
 	if (depth != 0.0f) {
diff --git a/source/blender/bmesh/operators/bmo_mesh_conv.c b/source/blender/bmesh/operators/bmo_mesh_conv.c
index af2a7cd996b..4b897a24c8a 100644
--- a/source/blender/bmesh/operators/bmo_mesh_conv.c
+++ b/source/blender/bmesh/operators/bmo_mesh_conv.c
@@ -55,7 +55,7 @@ void bmo_mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
 {
 	Object *ob  = BMO_slot_ptr_get(op->slots_in,  "object");
 	Mesh *me    = BMO_slot_ptr_get(op->slots_in,  "mesh");
-	int set_key = BMO_slot_bool_get(op->slots_in, "set_shapekey");
+	int set_key = BMO_slot_bool_get(op->slots_in, "use_shapekey");
 
 	BM_mesh_bm_from_me(bm, me, set_key, ob->shapenr);
 
@@ -71,7 +71,7 @@ void bmo_object_load_bmesh_exec(BMesh *bm, BMOperator *op)
 	Mesh *me = ob->data;
 
 	BMO_op_callf(bm, op->flag,
-	             "bmesh_to_mesh mesh=%p object=%p notessellation=%b",
+	             "bmesh_to_mesh mesh=%p object=%p skip_tessface=%b",
 	             me, ob, TRUE);
 }
 
@@ -79,7 +79,7 @@ void bmo_bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
 {
 	Mesh *me = BMO_slot_ptr_get(op->slots_in, "mesh");
 	/* Object *ob = BMO_slot_ptr_get(op, "object"); */
-	int dotess = !BMO_slot_bool_get(op->slots_in, "notessellation");
+	int dotess = !BMO_slot_bool_get(op->slots_in, "skip_tessface");
 
 	BM_mesh_bm_to_me(bm, me, dotess);
 }
diff --git a/source/blender/bmesh/operators/bmo_mirror.c b/source/blender/bmesh/operators/bmo_mirror.c
index 590e40195d0..8d3385ddfe6 100644
--- a/source/blender/bmesh/operators/bmo_mirror.c
+++ b/source/blender/bmesh/operators/bmo_mirror.c
@@ -50,7 +50,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
 	float mtx[4][4];
 	float imtx[4][4];
 	float scale[3] = {1.0f, 1.0f, 1.0f};
-	float dist = BMO_slot_float_get(op->slots_in, "mergedist");
+	float dist = BMO_slot_float_get(op->slots_in, "merge_dist");
 	int i, ototvert /*, ototedge */;
 	int axis = BMO_slot_int_get(op->slots_in, "axis");
 	int mirroru = BMO_slot_bool_get(op->slots_in, "mirror_u");
@@ -65,12 +65,12 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
 	BMO_op_initf(bm, &dupeop, op->flag, "duplicate geom=%s", op, "geom");
 	BMO_op_exec(bm, &dupeop);
 	
-	BMO_slot_buffer_flag_enable(bm, dupeop.slots_out, "newout", BM_ALL, ELE_NEW);
+	BMO_slot_buffer_flag_enable(bm, dupeop.slots_out, "geom.out", BM_ALL, ELE_NEW);
 
 	/* create old -> new mappin */
 	i = 0;
 	/* v2 = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); */ /* UNUSED */
-	BMO_ITER (v, &siter, dupeop.slots_out, "newout", BM_VERT) {
+	BMO_ITER (v, &siter, dupeop.slots_out, "geom.out", BM_VERT) {
 		BLI_array_grow_one(vmap);
 		vmap[i] = v;
 		/* v2 = BM_iter_step(&iter); */ /* UNUSED */
@@ -101,7 +101,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
 		int totlayer;
 		BMIter liter;
 
-		BMO_ITER (f, &siter, dupeop.slots_out, "newout", BM_FACE) {
+		BMO_ITER (f, &siter, dupeop.slots_out, "geom.out", BM_FACE) {
 			BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
 				totlayer = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV);
 				for (i = 0; i < totlayer; i++) {
@@ -120,7 +120,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op)
 	BMO_op_finish(bm, &weldop);
 	BMO_op_finish(bm, &dupeop);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "newout", BM_ALL, ELE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_ALL, ELE_NEW);
 
 	BLI_array_free(vmap);
 	BLI_array_free(emap);
diff --git a/source/blender/bmesh/operators/bmo_primitive.c b/source/blender/bmesh/operators/bmo_primitive.c
index cdc8df19f07..71f63bbaf28 100644
--- a/source/blender/bmesh/operators/bmo_primitive.c
+++ b/source/blender/bmesh/operators/bmo_primitive.c
@@ -227,14 +227,15 @@ static signed char monkeyf[250][4] = {
 
 void bmo_create_grid_exec(BMesh *bm, BMOperator *op)
 {
+	const float dia = BMO_slot_float_get(op->slots_in, "size");
+	const int tot = max_ii(2, BMO_slot_int_get(op->slots_in, "x_segments"));
+	const int seg = max_ii(2, BMO_slot_int_get(op->slots_in, "y_segments"));
+
 	BMOperator bmop, prevop;
 	BMVert *eve, *preveve;
 	BMEdge *e;
-	float vec[3], mat[4][4], phi, phid, dia = BMO_slot_float_get(op->slots_in, "size");
-	int a, tot = BMO_slot_int_get(op->slots_in, "xsegments"), seg = BMO_slot_int_get(op->slots_in, "ysegments");
-
-	if (tot < 2) tot = 2;
-	if (seg < 2) seg = 2;
+	float vec[3], mat[4][4], phi, phid;
+	int a;
 
 	BMO_slot_mat4_get(op->slots_in, "mat", mat);
 
@@ -267,37 +268,41 @@ void bmo_create_grid_exec(BMesh *bm, BMOperator *op)
 
 	for (a = 0; a < seg - 1; a++) {
 		if (a) {
-			BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%S", &prevop, "geomout");
+			BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%S", &prevop, "geom.out");
 			BMO_op_exec(bm, &bmop);
 			BMO_op_finish(bm, &prevop);
 
-			BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_VERT, VERT_MARK);
+			BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_VERT, VERT_MARK);
 		}
 		else {
 			BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%fe", EDGE_ORIG);
 			BMO_op_exec(bm, &bmop);
-			BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_VERT, VERT_MARK);
+			BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_VERT, VERT_MARK);
 		}
 
-		BMO_op_callf(bm, op->flag, "translate vec=%v verts=%S", vec, &bmop, "geomout");
+		BMO_op_callf(bm, op->flag, "translate vec=%v verts=%S", vec, &bmop, "geom.out");
 		prevop = bmop;
 	}
 
 	if (a)
 		BMO_op_finish(bm, &bmop);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
 {
+	const float dia = BMO_slot_float_get(op->slots_in, "diameter");
+	const int seg = BMO_slot_int_get(op->slots_in, "u_segments");
+	const int tot = BMO_slot_int_get(op->slots_in, "v_segments");
+
 	BMOperator bmop, prevop;
 	BMVert *eve, *preveve;
 	BMEdge *e;
 	BMIter iter;
 	float vec[3], mat[4][4], cmat[3][3], phi, q[4];
-	float phid, dia = BMO_slot_float_get(op->slots_in, "diameter");
-	int a, seg = BMO_slot_int_get(op->slots_in, "segments"), tot = BMO_slot_int_get(op->slots_in, "revolutions");
+	float phid;
+	int a;
 
 	BMO_slot_mat4_get(op->slots_in, "mat", mat);
 
@@ -333,7 +338,7 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
 
 	for (a = 0; a < seg; a++) {
 		if (a) {
-			BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%S", &prevop, "geomout");
+			BMO_op_initf(bm, &bmop, op->flag, "extrude_edge_only edges=%S", &prevop, "geom.out");
 			BMO_op_exec(bm, &bmop);
 			BMO_op_finish(bm, &prevop);
 		}
@@ -342,8 +347,8 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
 			BMO_op_exec(bm, &bmop);
 		}
 
-		BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_VERT, VERT_MARK);
-		BMO_op_callf(bm, op->flag, "rotate cent=%v mat=%m3 verts=%S", vec, cmat, &bmop, "geomout");
+		BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_VERT, VERT_MARK);
+		BMO_op_callf(bm, op->flag, "rotate cent=%v mat=%m3 verts=%S", vec, cmat, &bmop, "geom.out");
 		
 		prevop = bmop;
 	}
@@ -375,30 +380,33 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
 {
+	const float dia = BMO_slot_float_get(op->slots_in, "diameter");
+	const float dia_div = dia / 200.0f;
+	const int subdiv = BMO_slot_int_get(op->slots_in, "subdivisions");
+
 	BMVert *eva[12];
 	BMVert *v;
 	BMIter liter;
 	BMIter viter;
 	BMLoop *l;
 	float vec[3], mat[4][4] /* , phi, phid */;
-	float dia = BMO_slot_float_get(op->slots_in, "diameter");
-	int a, subdiv = BMO_slot_int_get(op->slots_in, "subdivisions");
+	int a;
 
 	BMO_slot_mat4_get(op->slots_in, "mat", mat);
 
 	/* phid = 2.0f * (float)M_PI / subdiv; */ /* UNUSED */
 	/* phi = 0.25f * (float)M_PI; */         /* UNUSED */
 
-	dia /= 200.0f;
+
 	for (a = 0; a < 12; a++) {
-		vec[0] = dia * icovert[a][0];
-		vec[1] = dia * icovert[a][1];
-		vec[2] = dia * icovert[a][2];
+		vec[0] = dia_div * icovert[a][0];
+		vec[1] = dia_div * icovert[a][1];
+		vec[2] = dia_div * icovert[a][2];
 		eva[a] = BM_vert_create(bm, vec, NULL);
 
 		BMO_elem_flag_enable(bm, eva[a], VERT_MARK);
@@ -421,22 +429,20 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
 		BMO_elem_flag_enable(bm, eftemp, FACE_MARK);
 	}
 
-	dia *= 200.0f;
-
 	if (subdiv > 1) {
 		BMOperator bmop;
 
 		BMO_op_initf(bm, &bmop, op->flag,
 		             "subdivide_edges edges=%fe "
 		             "smooth=%f "
-		             "numcuts=%i "
+		             "cuts=%i "
 		             "use_gridfill=%b use_sphere=%b",
 		             EDGE_MARK, dia, (1 << (subdiv - 1)) - 1,
 		             TRUE, TRUE);
 
 		BMO_op_exec(bm, &bmop);
-		BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_VERT, VERT_MARK);
-		BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_EDGE, EDGE_MARK);
+		BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_VERT, VERT_MARK);
+		BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_EDGE, EDGE_MARK);
 		BMO_op_finish(bm, &bmop);
 	}
 
@@ -447,7 +453,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_monkey_exec(BMesh *bm, BMOperator *op)
@@ -494,18 +500,19 @@ void bmo_create_monkey_exec(BMesh *bm, BMOperator *op)
 
 	MEM_freeN(tv);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 
 void bmo_create_circle_exec(BMesh *bm, BMOperator *op)
 {
+	const float dia = BMO_slot_float_get(op->slots_in, "diameter");
+	const int segs = BMO_slot_int_get(op->slots_in, "segments");
+	const int cap_ends = BMO_slot_bool_get(op->slots_in, "cap_ends");
+	const int cap_tris = BMO_slot_bool_get(op->slots_in, "cap_tris");
+
 	BMVert *v1, *lastv1 = NULL, *cent1, *firstv1 = NULL;
 	float vec[3], mat[4][4], phi, phid;
-	float dia = BMO_slot_float_get(op->slots_in, "diameter");
-	int segs = BMO_slot_int_get(op->slots_in, "segments");
-	int cap_ends = BMO_slot_bool_get(op->slots_in, "cap_ends");
-	int cap_tris = BMO_slot_bool_get(op->slots_in, "cap_tris");
 	int a;
 	
 	if (!segs)
@@ -566,7 +573,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op)
 		BMO_op_callf(bm, op->flag, "dissolve_faces faces=%ff", FACE_NEW);
 	}
 	
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_cone_exec(BMesh *bm, BMOperator *op)
@@ -662,7 +669,7 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op)
 	BM_face_create_quad_tri(bm, v1, v2, firstv2, firstv1, NULL, FALSE);
 
 	BMO_op_callf(bm, op->flag, "remove_doubles verts=%fv dist=%f", VERT_MARK, 0.000001);
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
 
 void bmo_create_cube_exec(BMesh *bm, BMOperator *op)
@@ -740,5 +747,5 @@ void bmo_create_cube_exec(BMesh *bm, BMOperator *op)
 	BM_face_create_quad_tri(bm, v1, v2, v3, v4, NULL, FALSE);
 	BM_face_create_quad_tri(bm, v8, v7, v6, v5, NULL, FALSE);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
diff --git a/source/blender/bmesh/operators/bmo_removedoubles.c b/source/blender/bmesh/operators/bmo_removedoubles.c
index 8187be734e8..e866abcb6dc 100644
--- a/source/blender/bmesh/operators/bmo_removedoubles.c
+++ b/source/blender/bmesh/operators/bmo_removedoubles.c
@@ -573,7 +573,7 @@ void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op)
 void bmo_find_doubles_exec(BMesh *bm, BMOperator *op)
 {
 	bmesh_find_doubles_common(bm, op,
-	                          op, op->slots_out, "targetmapout");
+	                          op, op->slots_out, "targetmap.out");
 }
 
 void bmo_automerge_exec(BMesh *bm, BMOperator *op)
@@ -601,7 +601,7 @@ void bmo_automerge_exec(BMesh *bm, BMOperator *op)
 
 	/* weld the vertices */
 	BMO_op_init(bm, &weldop, op->flag, "weld_verts");
-	BMO_slot_copy(&findop, slots_out, "targetmapout",
+	BMO_slot_copy(&findop, slots_out, "targetmap.out",
 	              &weldop, slots_in,  "targetmap");
 	BMO_op_exec(bm, &weldop);
 
diff --git a/source/blender/bmesh/operators/bmo_similar.c b/source/blender/bmesh/operators/bmo_similar.c
index 6193da60511..548e1adf17d 100644
--- a/source/blender/bmesh/operators/bmo_similar.c
+++ b/source/blender/bmesh/operators/bmo_similar.c
@@ -256,7 +256,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op)
 	MEM_freeN(indices);
 
 	/* transfer all marked faces to the output slot */
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, FACE_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, FACE_MARK);
 #undef FACE_MARK
 }
 
@@ -474,7 +474,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op)
 	MEM_freeN(indices);
 
 	/* transfer all marked edges to the output slot */
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EDGE_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_MARK);
 
 #undef EDGE_MARK
 }
@@ -608,7 +608,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op)
 	MEM_freeN(indices);
 	MEM_freeN(v_ext);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 
 #undef VERT_MARK
 }
diff --git a/source/blender/bmesh/operators/bmo_slide.c b/source/blender/bmesh/operators/bmo_slide.c
index 1fffaf358c0..9dde2461364 100644
--- a/source/blender/bmesh/operators/bmo_slide.c
+++ b/source/blender/bmesh/operators/bmo_slide.c
@@ -108,7 +108,7 @@ void bmo_slide_vert_exec(BMesh *bm, BMOperator *op)
 	}
 
 	/* Return the new edge. The same previously marked with VERT_MARK */
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 	return;
 }
 
diff --git a/source/blender/bmesh/operators/bmo_smooth_laplacian.c b/source/blender/bmesh/operators/bmo_smooth_laplacian.c
index 04bc2e98c0b..4137c31961c 100644
--- a/source/blender/bmesh/operators/bmo_smooth_laplacian.c
+++ b/source/blender/bmesh/operators/bmo_smooth_laplacian.c
@@ -78,7 +78,7 @@ static void delete_laplacian_system(LaplacianSystem *sys);
 static void delete_void_pointer(void *data);
 static void fill_laplacian_matrix(LaplacianSystem *sys);
 static void memset_laplacian_system(LaplacianSystem *sys, int val);
-static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez, int volumepreservation);
+static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez, int preserve_volume);
 static void volume_preservation(BMOperator *op, float vini, float vend, int usex, int usey, int usez);
 
 static void delete_void_pointer(void *data)
@@ -478,7 +478,7 @@ static void volume_preservation(BMOperator *op, float vini, float vend, int usex
 	}
 }
 
-static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez, int volumepreservation)
+static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez, int preserve_volume)
 {
 	int m_vertex_id;
 	float leni, lene;
@@ -509,7 +509,7 @@ static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez
 		}
 	}
 
-	if (volumepreservation) {
+	if (preserve_volume) {
 		vini = compute_volume(sys->bm);
 	}
 	BMO_ITER (v, &siter, sys->op->slots_in, "verts", BM_VERT) {
@@ -526,7 +526,7 @@ static void validate_solution(LaplacianSystem *sys, int usex, int usey, int usez
 			}
 		}
 	}
-	if (volumepreservation) {
+	if (preserve_volume) {
 		vend = compute_volume(sys->bm);
 		volume_preservation(sys->op, vini, vend, usex, usey, usez);
 	}
@@ -537,7 +537,7 @@ void bmo_smooth_laplacian_vert_exec(BMesh *bm, BMOperator *op)
 {
 	int i;
 	int m_vertex_id;
-	int usex, usey, usez, volumepreservation;
+	int usex, usey, usez, preserve_volume;
 	float lambda, lambda_border;
 	float w;
 	BMOIter siter;
@@ -558,7 +558,7 @@ void bmo_smooth_laplacian_vert_exec(BMesh *bm, BMOperator *op)
 	usex = BMO_slot_bool_get(op->slots_in, "use_x");
 	usey = BMO_slot_bool_get(op->slots_in, "use_y");
 	usez = BMO_slot_bool_get(op->slots_in, "use_z");
-	volumepreservation = BMO_slot_bool_get(op->slots_in, "volume_preservation");
+	preserve_volume = BMO_slot_bool_get(op->slots_in, "preserve_volume");
 
 
 	nlNewContext();
@@ -612,7 +612,7 @@ void bmo_smooth_laplacian_vert_exec(BMesh *bm, BMOperator *op)
 	nlEnd(NL_SYSTEM);
 
 	if (nlSolveAdvanced(NULL, NL_TRUE) ) {
-		validate_solution(sys, usex, usey, usez, volumepreservation);
+		validate_solution(sys, usex, usey, usez, preserve_volume);
 	}
 
 	delete_laplacian_system(sys);
diff --git a/source/blender/bmesh/operators/bmo_subdivide.c b/source/blender/bmesh/operators/bmo_subdivide.c
index c693851336a..5032545af89 100644
--- a/source/blender/bmesh/operators/bmo_subdivide.c
+++ b/source/blender/bmesh/operators/bmo_subdivide.c
@@ -719,12 +719,12 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
 	
 	BMO_slot_buffer_flag_enable(bm, op->slots_in, "edges", BM_EDGE, SUBD_SPLIT);
 	
-	numcuts = BMO_slot_int_get(op->slots_in, "numcuts");
+	numcuts = BMO_slot_int_get(op->slots_in, "cuts");
 	seed = BMO_slot_int_get(op->slots_in, "seed");
 	smooth = BMO_slot_float_get(op->slots_in, "smooth");
 	fractal = BMO_slot_float_get(op->slots_in, "fractal");
 	along_normal = BMO_slot_float_get(op->slots_in, "along_normal");
-	cornertype = BMO_slot_int_get(op->slots_in, "quadcornertype");
+	cornertype = BMO_slot_int_get(op->slots_in, "quad_corner_type");
 
 	use_singleedge = BMO_slot_bool_get(op->slots_in, "use_singleedge");
 	use_gridfill   = BMO_slot_bool_get(op->slots_in, "use_gridfill");
@@ -1074,10 +1074,10 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
 	BLI_array_free(loops_split);
 	BLI_array_free(loops);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "innerout", BM_ALL, ELE_INNER);
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "splitout", BM_ALL, ELE_SPLIT);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_inner.out", BM_ALL, ELE_INNER);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_split.out", BM_ALL, ELE_SPLIT);
 	
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_ALL, ELE_INNER | ELE_SPLIT | SUBD_SPLIT);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_ALL, ELE_INNER | ELE_SPLIT | SUBD_SPLIT);
 }
 
 /* editmesh-emulating function */
@@ -1094,8 +1094,8 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
 	BMO_op_initf(bm, &op, BMO_FLAG_DEFAULTS,
 	             "subdivide_edges edges=%he "
 	             "smooth=%f fractal=%f along_normal=%f "
-	             "numcuts=%i "
-	             "quadcornertype=%i "
+	             "cuts=%i "
+	             "quad_corner_type=%i "
 	             "use_singleedge=%b use_gridfill=%b "
 	             "seed=%i",
 	             edge_hflag,
@@ -1111,7 +1111,7 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
 		BMOIter iter;
 		BMElem *ele;
 
-		for (ele = BMO_iter_new(&iter, op.slots_out, "innerout", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) {
+		for (ele = BMO_iter_new(&iter, op.slots_out, "geom_inner.out", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) {
 			BM_elem_select_set(bm, ele, TRUE);
 		}
 	}
@@ -1122,7 +1122,7 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag,
 		/* deselect input */
 		BM_mesh_elem_hflag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE);
 
-		for (ele = BMO_iter_new(&iter, op.slots_out, "innerout", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) {
+		for (ele = BMO_iter_new(&iter, op.slots_out, "geom_inner.out", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) {
 			BM_elem_select_set(bm, ele, TRUE);
 
 			if (ele->head.htype == BM_VERT) {
@@ -1157,7 +1157,7 @@ void bmo_bisect_edges_exec(BMesh *bm, BMOperator *op)
 	SubDParams params = {0};
 	int skey;
 	
-	params.numcuts = BMO_slot_int_get(op->slots_in, "numcuts");
+	params.numcuts = BMO_slot_int_get(op->slots_in, "cuts");
 	params.op = op;
 	
 	BM_data_layer_add(bm, &bm->vdata, CD_SHAPEKEY);
@@ -1170,7 +1170,7 @@ void bmo_bisect_edges_exec(BMesh *bm, BMOperator *op)
 		bm_subdivide_multicut(bm, e, &params, e->v1, e->v2);
 	}
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "splitout", BM_ALL, ELE_SPLIT);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom_split.out", BM_ALL, ELE_SPLIT);
 
 	BM_data_layer_free_n(bm, &bm->vdata, CD_SHAPEKEY, skey);
 }
diff --git a/source/blender/bmesh/operators/bmo_symmetrize.c b/source/blender/bmesh/operators/bmo_symmetrize.c
index a2f5d7d2d7c..8c440cae83e 100644
--- a/source/blender/bmesh/operators/bmo_symmetrize.c
+++ b/source/blender/bmesh/operators/bmo_symmetrize.c
@@ -658,6 +658,6 @@ void bmo_symmetrize_exec(BMesh *bm, BMOperator *op)
 	BLI_ghash_free(symm.vert_symm_map, NULL, NULL);
 	BLI_ghash_free(symm.edge_split_map, NULL, NULL);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout",
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out",
 	                                  BM_ALL, SYMM_OUTPUT_GEOM);
 }
diff --git a/source/blender/bmesh/operators/bmo_triangulate.c b/source/blender/bmesh/operators/bmo_triangulate.c
index 55cc111b68d..324c95a0ff7 100644
--- a/source/blender/bmesh/operators/bmo_triangulate.c
+++ b/source/blender/bmesh/operators/bmo_triangulate.c
@@ -64,14 +64,14 @@ void bmo_triangulate_exec(BMesh *bm, BMOperator *op)
 
 		BM_face_triangulate(bm, face, projectverts, EDGE_NEW, FACE_NEW, newfaces, use_beauty);
 
-		BMO_slot_map_ptr_insert(op, op->slots_out, "facemap_out", face, face);
+		BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", face, face);
 		for (i = 0; newfaces[i]; i++) {
-			BMO_slot_map_ptr_insert(op, op->slots_out, "facemap_out", newfaces[i], face);
+			BMO_slot_map_ptr_insert(op, op->slots_out, "facemap.out", newfaces[i], face);
 		}
 	}
 	
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EDGE_NEW);
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faceout", BM_FACE, FACE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, FACE_NEW);
 	
 	BLI_array_free(projectverts);
 	BLI_array_free(newfaces);
@@ -150,7 +150,7 @@ void bmo_beautify_fill_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 	
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_EDGE | BM_FACE, ELE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_EDGE | BM_FACE, ELE_NEW);
 }
 
 void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op)
@@ -212,8 +212,8 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op)
 	/* clean up fill */
 	BMO_op_initf(bm, &bmop, op->flag, "beautify_fill faces=%ff constrain_edges=%fe", ELE_NEW, EDGE_MARK);
 	BMO_op_exec(bm, &bmop);
-	BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geomout", BM_FACE | BM_EDGE, ELE_NEW);
+	BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_FACE | BM_EDGE, ELE_NEW);
 	BMO_op_finish(bm, &bmop);
 	
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_EDGE | BM_FACE, ELE_NEW);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_EDGE | BM_FACE, ELE_NEW);
 }
diff --git a/source/blender/bmesh/operators/bmo_utils.c b/source/blender/bmesh/operators/bmo_utils.c
index 31ed841c06f..d56b2ca0d73 100644
--- a/source/blender/bmesh/operators/bmo_utils.c
+++ b/source/blender/bmesh/operators/bmo_utils.c
@@ -48,7 +48,7 @@ void bmo_create_vert_exec(BMesh *bm, BMOperator *op)
 	BMO_slot_vec_get(op->slots_in, "co", vec);
 
 	BMO_elem_flag_enable(bm, BM_vert_create(bm, vec, NULL), 1);
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "newvertout", BM_VERT, 1);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vert.out", BM_VERT, 1);
 }
 
 void bmo_transform_exec(BMesh *UNUSED(bm), BMOperator *op)
@@ -122,8 +122,8 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op)
 {
 	BMOIter siter;
 	BMEdge *e, *e2;
-	int ccw = BMO_slot_bool_get(op->slots_in, "ccw");
-	int is_single = BMO_slot_buffer_count(op->slots_in, "edges") == 1;
+	const int use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw");
+	const int is_single = BMO_slot_buffer_count(op->slots_in, "edges") == 1;
 	short check_flag = is_single ?
 	            BM_EDGEROT_CHECK_EXISTS :
 	            BM_EDGEROT_CHECK_EXISTS | BM_EDGEROT_CHECK_DEGENERATE;
@@ -144,7 +144,7 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op)
 				    BMO_elem_flag_test(bm, fb, FACE_TAINT) == FALSE)
 				{
 
-					if (!(e2 = BM_edge_rotate(bm, e, ccw, check_flag))) {
+					if (!(e2 = BM_edge_rotate(bm, e, use_ccw, check_flag))) {
 #if 0
 						BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Could not rotate edge");
 						return;
@@ -162,7 +162,7 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edgeout", BM_EDGE, EDGE_OUT);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_OUT);
 
 #undef EDGE_OUT
 #undef FACE_TAINT
@@ -266,7 +266,7 @@ static void bmo_region_extend_constrict(BMesh *bm, BMOperator *op, int usefaces)
 void bmo_region_extend_exec(BMesh *bm, BMOperator *op)
 {
 	int use_faces = BMO_slot_bool_get(op->slots_in, "use_faces");
-	int constrict = BMO_slot_bool_get(op->slots_in, "constrict");
+	int constrict = BMO_slot_bool_get(op->slots_in, "use_constrict");
 
 	BMO_slot_buffer_flag_enable(bm, op->slots_in, "geom", BM_ALL, SEL_ORIG);
 
@@ -275,7 +275,7 @@ void bmo_region_extend_exec(BMesh *bm, BMOperator *op)
 	else
 		bmo_region_extend_extend(bm, op, use_faces);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geomout", BM_ALL, SEL_FLAG);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "geom.out", BM_ALL, SEL_FLAG);
 }
 
 /********* righthand faces implementation ****** */
@@ -314,7 +314,7 @@ void bmo_recalc_face_normals_exec(BMesh *bm, BMOperator *op)
 	BLI_array_declare(fstack);
 	BMLoop *l, *l2;
 	float maxx, maxx_test, cent[3];
-	int i, i_max, flagflip = BMO_slot_bool_get(op->slots_in, "do_flip");
+	int i, i_max, flagflip = BMO_slot_bool_get(op->slots_in, "use_flip");
 
 	startf = NULL;
 	maxx = -1.0e10;
@@ -421,7 +421,7 @@ void bmo_smooth_vert_exec(BMesh *UNUSED(bm), BMOperator *op)
 	BMEdge *e;
 	BLI_array_declare(cos);
 	float (*cos)[3] = NULL;
-	float *co, *co2, clipdist = BMO_slot_float_get(op->slots_in, "clipdist");
+	float *co, *co2, clip_dist = BMO_slot_float_get(op->slots_in, "clip_dist");
 	int i, j, clipx, clipy, clipz;
 	int xaxis, yaxis, zaxis;
 	
@@ -454,11 +454,11 @@ void bmo_smooth_vert_exec(BMesh *UNUSED(bm), BMOperator *op)
 		mul_v3_fl(co, 1.0f / (float)j);
 		mid_v3_v3v3(co, co, v->co);
 
-		if (clipx && fabsf(v->co[0]) <= clipdist)
+		if (clipx && fabsf(v->co[0]) <= clip_dist)
 			co[0] = 0.0f;
-		if (clipy && fabsf(v->co[1]) <= clipdist)
+		if (clipy && fabsf(v->co[1]) <= clip_dist)
 			co[1] = 0.0f;
-		if (clipz && fabsf(v->co[2]) <= clipdist)
+		if (clipz && fabsf(v->co[2]) <= clip_dist)
 			co[2] = 0.0f;
 
 		i++;
@@ -489,11 +489,11 @@ void bmo_rotate_uvs_exec(BMesh *bm, BMOperator *op)
 	BMFace *fs;       /* current face */
 	BMIter l_iter;    /* iteration loop */
 
-	int dir = BMO_slot_int_get(op->slots_in, "dir");
+	const int use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw");
 
 	BMO_ITER (fs, &fs_iter, op->slots_in, "faces", BM_FACE) {
 		if (CustomData_has_layer(&(bm->ldata), CD_MLOOPUV)) {
-			if (dir == DIRECTION_CW) { /* same loops direction */
+			if (use_ccw == FALSE) {  /* same loops direction */
 				BMLoop *lf;	/* current face loops */
 				MLoopUV *f_luv; /* first face loop uv */
 				float p_uv[2];	/* previous uvs */
@@ -517,7 +517,7 @@ void bmo_rotate_uvs_exec(BMesh *bm, BMOperator *op)
 
 				copy_v2_v2(f_luv->uv, p_uv);
 			}
-			else if (dir == DIRECTION_CCW) { /* counter loop direction */
+			else { /* counter loop direction */
 				BMLoop *lf;	/* current face loops */
 				MLoopUV *p_luv; /* previous loop uv */
 				MLoopUV *luv;
@@ -594,11 +594,11 @@ void bmo_rotate_colors_exec(BMesh *bm, BMOperator *op)
 	BMFace *fs;       /* current face */
 	BMIter l_iter;    /* iteration loop */
 
-	int dir = BMO_slot_int_get(op->slots_in, "dir");
+	const int use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw");
 
 	BMO_ITER (fs, &fs_iter, op->slots_in, "faces", BM_FACE) {
 		if (CustomData_has_layer(&(bm->ldata), CD_MLOOPCOL)) {
-			if (dir == DIRECTION_CW) { /* same loops direction */
+			if (use_ccw == FALSE) {  /* same loops direction */
 				BMLoop *lf;	/* current face loops */
 				MLoopCol *f_lcol; /* first face loop color */
 				MLoopCol p_col;	/* previous color */
@@ -622,7 +622,7 @@ void bmo_rotate_colors_exec(BMesh *bm, BMOperator *op)
 
 				*f_lcol = p_col;
 			}
-			else if (dir == DIRECTION_CCW) { /* counter loop direction */
+			else {  /* counter loop direction */
 				BMLoop *lf;	/* current face loops */
 				MLoopCol *p_lcol; /* previous loop color */
 				MLoopCol *lcol;
@@ -796,5 +796,5 @@ void bmo_shortest_path_exec(BMesh *bm, BMOperator *op)
 	BLI_heap_free(h, NULL);
 	MEM_freeN(vert_list);
 
-	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vertout", BM_VERT, VERT_MARK);
+	BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK);
 }
diff --git a/source/blender/bmesh/operators/bmo_wireframe.c b/source/blender/bmesh/operators/bmo_wireframe.c
index b34d9edc430..532145ab129 100644
--- a/source/blender/bmesh/operators/bmo_wireframe.c
+++ b/source/blender/bmesh/operators/bmo_wireframe.c
@@ -423,5 +423,5 @@ void bmo_wireframe_exec(BMesh *bm, BMOperator *op)
 	MEM_freeN(verts_pos);
 	MEM_freeN(verts_loop);
 
-	BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faceout", BM_FACE, BM_ELEM_TAG);
+	BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faces.out", BM_FACE, BM_ELEM_TAG);
 }
diff --git a/source/blender/editors/armature/editarmature.c b/source/blender/editors/armature/editarmature.c
index 48da23d5e8d..e801d3689e5 100644
--- a/source/blender/editors/armature/editarmature.c
+++ b/source/blender/editors/armature/editarmature.c
@@ -3569,16 +3569,16 @@ static int armature_subdivide_exec(bContext *C, wmOperator *op)
 	Object *obedit = CTX_data_edit_object(C);
 	bArmature *arm = obedit->data;
 	EditBone *newbone, *tbone;
-	int numcuts, i;
+	int cuts, i;
 	
 	/* there may not be a number_cuts property defined (for 'simple' subdivide) */
-	numcuts = RNA_int_get(op->ptr, "number_cuts");
+	cuts = RNA_int_get(op->ptr, "number_cuts");
 	
 	/* loop over all editable bones */
 	// XXX the old code did this in reverse order though!
 	CTX_DATA_BEGIN(C, EditBone *, ebone, selected_editable_bones)
 	{
-		for (i = numcuts + 1; i > 1; i--) {
+		for (i = cuts + 1; i > 1; i--) {
 			/* compute cut ratio first */
 			float cutratio = 1.0f / (float)i;
 			float cutratioI = 1.0f - cutratio;
diff --git a/source/blender/editors/mesh/editmesh_add.c b/source/blender/editors/mesh/editmesh_add.c
index b8736d4f1d0..ee96ba71cdd 100644
--- a/source/blender/editors/mesh/editmesh_add.c
+++ b/source/blender/editors/mesh/editmesh_add.c
@@ -108,7 +108,7 @@ static int add_primitive_plane_exec(bContext *C, wmOperator *op)
 	obedit = make_prim_init(C, "Plane", &dia, mat, &state, loc, rot, layer);
 	em = BMEdit_FromObject(obedit);
 
-	if (!EDBM_op_call_and_selectf(em, op, "vertout",
+	if (!EDBM_op_call_and_selectf(em, op, "verts.out",
 	                              "create_grid xsegments=%i ysegments=%i size=%f mat=%m4", 1, 1, dia, mat))
 	{
 		return OPERATOR_CANCELLED;
@@ -149,7 +149,7 @@ static int add_primitive_cube_exec(bContext *C, wmOperator *op)
 	obedit = make_prim_init(C, "Cube", &dia, mat, &state, loc, rot, layer);
 	em = BMEdit_FromObject(obedit);
 
-	if (!EDBM_op_call_and_selectf(em, op, "vertout", "create_cube mat=%m4 size=%f", mat, dia * 2.0f)) {
+	if (!EDBM_op_call_and_selectf(em, op, "verts.out", "create_cube mat=%m4 size=%f", mat, dia * 2.0f)) {
 		return OPERATOR_CANCELLED;
 	}
 
@@ -198,7 +198,7 @@ static int add_primitive_circle_exec(bContext *C, wmOperator *op)
 	obedit = make_prim_init(C, "Circle", &dia, mat, &state, loc, rot, layer);
 	em = BMEdit_FromObject(obedit);
 
-	if (!EDBM_op_call_and_selectf(em, op, "vertout",
+	if (!EDBM_op_call_and_selectf(em, op, "verts.out",
 	                              "create_circle segments=%i diameter=%f cap_ends=%b cap_tris=%b mat=%m4",
 	                              RNA_int_get(op->ptr, "vertices"), RNA_float_get(op->ptr, "radius") * dia,
 	                              cap_end, cap_tri, mat))
@@ -253,7 +253,7 @@ static int add_primitive_cylinder_exec(bContext *C, wmOperator *op)
 	em = BMEdit_FromObject(obedit);
 
 	if (!EDBM_op_call_and_selectf(
-	        em, op, "vertout",
+	        em, op, "verts.out",
 	        "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f mat=%m4",
 	        RNA_int_get(op->ptr, "vertices"),
 	        RNA_float_get(op->ptr, "radius") * dia,
@@ -313,7 +313,7 @@ static int add_primitive_cone_exec(bContext *C, wmOperator *op)
 	em = BMEdit_FromObject(obedit);
 
 	if (!EDBM_op_call_and_selectf(
-	        em, op, "vertout",
+	        em, op, "verts.out",
 	        "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f mat=%m4",
 	        RNA_int_get(op->ptr, "vertices"), RNA_float_get(op->ptr, "radius1") * dia,
 	        RNA_float_get(op->ptr, "radius2") * dia, cap_end, cap_tri, RNA_float_get(op->ptr, "depth") * dia, mat))
@@ -368,8 +368,8 @@ static int add_primitive_grid_exec(bContext *C, wmOperator *op)
 	obedit = make_prim_init(C, "Grid", &dia, mat, &state, loc, rot, layer);
 	em = BMEdit_FromObject(obedit);
 
-	if (!EDBM_op_call_and_selectf(em, op, "vertout",
-	                              "create_grid xsegments=%i ysegments=%i size=%f mat=%m4",
+	if (!EDBM_op_call_and_selectf(em, op, "verts.out",
+	                              "create_grid x_segments=%i y_segments=%i size=%f mat=%m4",
 	                              RNA_int_get(op->ptr, "x_subdivisions"),
 	                              RNA_int_get(op->ptr, "y_subdivisions"),
 	                              RNA_float_get(op->ptr, "size") * dia, mat))
@@ -427,7 +427,7 @@ static int add_primitive_monkey_exec(bContext *C, wmOperator *op)
 
 	em = BMEdit_FromObject(obedit);
 
-	if (!EDBM_op_call_and_selectf(em, op, "vertout", "create_monkey mat=%m4", mat)) {
+	if (!EDBM_op_call_and_selectf(em, op, "verts.out", "create_monkey mat=%m4", mat)) {
 		return OPERATOR_CANCELLED;
 	}
 
@@ -466,8 +466,8 @@ static int add_primitive_uvsphere_exec(bContext *C, wmOperator *op)
 	obedit = make_prim_init(C, "Sphere", &dia, mat, &state, loc, rot, layer);
 	em = BMEdit_FromObject(obedit);
 
-	if (!EDBM_op_call_and_selectf(em, op, "vertout",
-	                              "create_uvsphere segments=%i revolutions=%i diameter=%f mat=%m4",
+	if (!EDBM_op_call_and_selectf(em, op, "verts.out",
+	                              "create_uvsphere u_segments=%i v_segments=%i diameter=%f mat=%m4",
 	                              RNA_int_get(op->ptr, "segments"), RNA_int_get(op->ptr, "ring_count"),
 	                              RNA_float_get(op->ptr, "size") * dia, mat))
 	{
@@ -518,7 +518,7 @@ static int add_primitive_icosphere_exec(bContext *C, wmOperator *op)
 	em = BMEdit_FromObject(obedit);
 
 	if (!EDBM_op_call_and_selectf(
-	        em, op, "vertout",
+	        em, op, "verts.out",
 	        "create_icosphere subdivisions=%i diameter=%f mat=%m4",
 	        RNA_int_get(op->ptr, "subdivisions"),
 	        RNA_float_get(op->ptr, "size") * dia, mat))
diff --git a/source/blender/editors/mesh/editmesh_knife.c b/source/blender/editors/mesh/editmesh_knife.c
index 5ba85115b2f..aed16be5b73 100644
--- a/source/blender/editors/mesh/editmesh_knife.c
+++ b/source/blender/editors/mesh/editmesh_knife.c
@@ -1823,7 +1823,7 @@ static void remerge_faces(KnifeTool_OpData *kcd)
 	BMO_op_initf(bm, &bmop, "beautify_fill faces=%ff constrain_edges=%fe", FACE_NEW, BOUNDARY);
 
 	BMO_op_exec(bm, &bmop);
-	BMO_slot_buffer_flag_enable(bm, &bmop, "geomout", BM_FACE, FACE_NEW);
+	BMO_slot_buffer_flag_enable(bm, &bmop, "geom.out", BM_FACE, FACE_NEW);
 
 	BMO_op_finish(bm, &bmop);
 
diff --git a/source/blender/editors/mesh/editmesh_select.c b/source/blender/editors/mesh/editmesh_select.c
index a98983159b3..8e13dcf2580 100644
--- a/source/blender/editors/mesh/editmesh_select.c
+++ b/source/blender/editors/mesh/editmesh_select.c
@@ -732,7 +732,7 @@ static int similar_face_select_exec(bContext *C, wmOperator *op)
 	EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
 	/* select the output */
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_ALL, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
 	/* finish the operator */
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
@@ -773,7 +773,7 @@ static int similar_edge_select_exec(bContext *C, wmOperator *op)
 	EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
 	/* select the output */
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edgeout", BM_ALL, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edges.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 	EDBM_selectmode_flush(em);
 
 	/* finish the operator */
@@ -817,7 +817,7 @@ static int similar_vert_select_exec(bContext *C, wmOperator *op)
 	EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
 	/* select the output */
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "vertout", BM_ALL, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "verts.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
 	/* finish the operator */
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
diff --git a/source/blender/editors/mesh/editmesh_slide.c b/source/blender/editors/mesh/editmesh_slide.c
index 9b2e2313945..c32033054e0 100644
--- a/source/blender/editors/mesh/editmesh_slide.c
+++ b/source/blender/editors/mesh/editmesh_slide.c
@@ -741,7 +741,7 @@ static int edbm_vertex_slide_exec_ex(bContext *C, wmOperator *op, const int do_u
 	BMO_slot_buffer_hflag_disable(bm, bmop.slots_in, "edge", BM_ALL, BM_ELEM_SELECT, TRUE);
 
 	/* Select the output vert */
-	BMO_slot_buffer_hflag_enable(bm, bmop.slots_out, "vertout", BM_ALL, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(bm, bmop.slots_out, "verts.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
 	/* Flush the select buffers */
 	EDBM_selectmode_flush(em);
diff --git a/source/blender/editors/mesh/editmesh_tools.c b/source/blender/editors/mesh/editmesh_tools.c
index 3e979878b41..4a739f0aede 100644
--- a/source/blender/editors/mesh/editmesh_tools.c
+++ b/source/blender/editors/mesh/editmesh_tools.c
@@ -242,7 +242,7 @@ static short edbm_extrude_discrete_faces(BMEditMesh *em, wmOperator *op, const c
 
 	BMO_op_exec(em->bm, &bmop);
 	
-	BMO_ITER (f, &siter, bmop.slots_out, "faceout", BM_FACE) {
+	BMO_ITER (f, &siter, bmop.slots_out, "faces.out", BM_FACE) {
 		BM_face_select_set(em->bm, f, TRUE);
 
 		/* set face vertex normals to face normal */
@@ -269,7 +269,7 @@ static short edbm_extrude_edges_indiv(BMEditMesh *em, wmOperator *op, const char
 	EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
 	BMO_op_exec(em->bm, &bmop);
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geomout", BM_VERT | BM_EDGE, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_VERT | BM_EDGE, BM_ELEM_SELECT, TRUE);
 
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return 0;
@@ -289,7 +289,7 @@ static short edbm_extrude_verts_indiv(BMEditMesh *em, wmOperator *op, const char
 	BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_in, "verts", BM_VERT, BM_ELEM_SELECT, TRUE);
 
 	BMO_op_exec(em->bm, &bmop);
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "vertout", BM_VERT, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "verts.out", BM_VERT, BM_ELEM_SELECT, TRUE);
 
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return 0;
@@ -310,7 +310,7 @@ static short edbm_extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
 	BMElem *ele;
 	
 	BMO_op_init(bm, &extop, BMO_FLAG_DEFAULTS, "extrude_face_region");
-	BMO_slot_buffer_from_enabled_hflag(bm, &extop, extop.slots_in, "edgefacein", BM_VERT | BM_EDGE | BM_FACE, hflag);
+	BMO_slot_buffer_from_enabled_hflag(bm, &extop, extop.slots_in, "geom", BM_VERT | BM_EDGE | BM_FACE, hflag);
 
 	/* If a mirror modifier with clipping is on, we need to adjust some 
 	 * of the cases above to handle edges on the line of symmetry.
@@ -350,21 +350,21 @@ static short edbm_extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
 							if ((fabsf(co1[0]) < mmd->tolerance) &&
 							    (fabsf(co2[0]) < mmd->tolerance))
 							{
-								BMO_slot_map_ptr_insert(&extop, extop.slots_in, "exclude", edge, NULL);
+								BMO_slot_map_ptr_insert(&extop, extop.slots_in, "edges_exclude", edge, NULL);
 							}
 						}
 						if (mmd->flag & MOD_MIR_AXIS_Y) {
 							if ((fabsf(co1[1]) < mmd->tolerance) &&
 							    (fabsf(co2[1]) < mmd->tolerance))
 							{
-								BMO_slot_map_ptr_insert(&extop, extop.slots_in, "exclude", edge, NULL);
+								BMO_slot_map_ptr_insert(&extop, extop.slots_in, "edges_exclude", edge, NULL);
 							}
 						}
 						if (mmd->flag & MOD_MIR_AXIS_Z) {
 							if ((fabsf(co1[2]) < mmd->tolerance) &&
 							    (fabsf(co2[2]) < mmd->tolerance))
 							{
-								BMO_slot_map_ptr_insert(&extop, extop.slots_in, "exclude", edge, NULL);
+								BMO_slot_map_ptr_insert(&extop, extop.slots_in, "edges_exclude", edge, NULL);
 							}
 						}
 					}
@@ -379,7 +379,7 @@ static short edbm_extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
 
 	zero_v3(nor);
 	
-	BMO_ITER (ele, &siter, extop.slots_out, "geomout", BM_ALL) {
+	BMO_ITER (ele, &siter, extop.slots_out, "geom.out", BM_ALL) {
 		BM_elem_select_set(bm, ele, TRUE);
 
 		if (ele->head.htype == BM_FACE) {
@@ -449,7 +449,7 @@ static int edbm_extrude_repeat_exec(bContext *C, wmOperator *op)
 
 	for (a = 0; a < steps; a++) {
 		edbm_extrude_edge(obedit, em, BM_ELEM_SELECT, nor);
-		//BMO_op_callf(em->bm, BMO_FLAG_DEFAULTS, "extrude_face_region edgefacein=%hef", BM_ELEM_SELECT);
+		//BMO_op_callf(em->bm, BMO_FLAG_DEFAULTS, "extrude_face_region geom=%hef", BM_ELEM_SELECT);
 		BMO_op_callf(em->bm, BMO_FLAG_DEFAULTS,
 		             "translate vec=%v verts=%hv",
 		             (float *)dvec, BM_ELEM_SELECT);
@@ -915,7 +915,7 @@ static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, wmEvent
 		EDBM_op_init(vc.em, &bmop, op, "create_vert co=%v", min);
 		BMO_op_exec(vc.em->bm, &bmop);
 
-		BMO_ITER (v1, &oiter, bmop.slots_out, "newvertout", BM_VERT) {
+		BMO_ITER (v1, &oiter, bmop.slots_out, "vert.out", BM_VERT) {
 			BM_vert_select_set(vc.em->bm, v1, TRUE);
 		}
 
@@ -1110,8 +1110,8 @@ static int edbm_add_edge_face_exec(bContext *C, wmOperator *op)
 	}
 	
 	BMO_op_exec(em->bm, &bmop);
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edgeout", BM_EDGE, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edges.out", BM_EDGE, BM_ELEM_SELECT, TRUE);
 
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
@@ -1261,7 +1261,7 @@ static int edbm_vert_connect(bContext *C, wmOperator *op)
 		return OPERATOR_CANCELLED;
 	}
 	BMO_op_exec(bm, &bmop);
-	len = BMO_slot_get(bmop.slots_out, "edgeout")->len;
+	len = BMO_slot_get(bmop.slots_out, "edges.out")->len;
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
 	}
@@ -1301,7 +1301,7 @@ static int edbm_edge_split_exec(bContext *C, wmOperator *op)
 		return OPERATOR_CANCELLED;
 	}
 	BMO_op_exec(bm, &bmop);
-	len = BMO_slot_get(bmop.slots_out, "edgeout")->len;
+	len = BMO_slot_get(bmop.slots_out, "edges.out")->len;
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
 	}
@@ -1339,7 +1339,7 @@ static int edbm_duplicate_exec(bContext *C, wmOperator *op)
 	BMO_op_exec(em->bm, &bmop);
 	EDBM_flag_disable_all(em, BM_ELEM_SELECT);
 
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "newout", BM_ALL, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
@@ -1405,8 +1405,8 @@ void MESH_OT_flip_normals(wmOperatorType *ot)
 }
 
 static const EnumPropertyItem direction_items[] = {
-	{DIRECTION_CW, "CW", 0, "Clockwise", ""},
-	{DIRECTION_CCW, "CCW", 0, "Counter Clockwise", ""},
+	{FALSE, "CW", 0, "Clockwise", ""},
+	{TRUE, "CCW", 0, "Counter Clockwise", ""},
 	{0, NULL, 0, NULL, NULL}
 };
 
@@ -1418,7 +1418,7 @@ static int edbm_edge_rotate_selected_exec(bContext *C, wmOperator *op)
 	BMOperator bmop;
 	BMEdge *eed;
 	BMIter iter;
-	const int do_ccw = RNA_enum_get(op->ptr, "direction") == 1;
+	const int use_ccw = RNA_boolean_get(op->ptr, "use_ccw");
 	int tot = 0;
 
 	if (em->bm->totedgesel == 0) {
@@ -1448,8 +1448,8 @@ static int edbm_edge_rotate_selected_exec(bContext *C, wmOperator *op)
 		BKE_report(op->reports, RPT_ERROR, "Could not find any selected edges that can be rotated");
 		return OPERATOR_CANCELLED;
 	}
-	
-	EDBM_op_init(em, &bmop, op, "rotate_edges edges=%he ccw=%b", BM_ELEM_TAG, do_ccw);
+
+	EDBM_op_init(em, &bmop, op, "rotate_edges edges=%he use_ccw=%b", BM_ELEM_TAG, use_ccw);
 
 	/* avoids leaving old verts selected which can be a problem running multiple times,
 	 * since this means the edges become selected around the face which then attempt to rotate */
@@ -1457,8 +1457,8 @@ static int edbm_edge_rotate_selected_exec(bContext *C, wmOperator *op)
 
 	BMO_op_exec(em->bm, &bmop);
 	/* edges may rotate into hidden vertices, if this does _not_ run we get an ilogical state */
-	BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "edgeout", BM_EDGE, BM_ELEM_HIDDEN, TRUE);
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edgeout", BM_EDGE, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "edges.out", BM_EDGE, BM_ELEM_HIDDEN, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "edges.out", BM_EDGE, BM_ELEM_SELECT, TRUE);
 	EDBM_selectmode_flush(em);
 
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
@@ -1485,7 +1485,7 @@ void MESH_OT_edge_rotate(wmOperatorType *ot)
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
 	/* props */
-	RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CW, "Direction", "Direction to rotate edge around");
+	RNA_def_boolean(ot->srna, "use_ccw", FALSE, "Counter Clockwise", "");
 }
 
 
@@ -1553,7 +1553,7 @@ static int edbm_normals_make_consistent_exec(bContext *C, wmOperator *op)
 	
 	/* doflip has to do with bmesh_rationalize_normals, it's an internal
 	 * thing */
-	if (!EDBM_op_callf(em, op, "recalc_face_normals faces=%hf do_flip=%b", BM_ELEM_SELECT, TRUE))
+	if (!EDBM_op_callf(em, op, "recalc_face_normals faces=%hf use_flip=%b", BM_ELEM_SELECT, TRUE))
 		return OPERATOR_CANCELLED;
 
 	if (RNA_boolean_get(op->ptr, "inside"))
@@ -1590,7 +1590,7 @@ static int edbm_do_smooth_vertex_exec(bContext *C, wmOperator *op)
 	ModifierData *md;
 	int mirrx = FALSE, mirry = FALSE, mirrz = FALSE;
 	int i, repeat;
-	float clipdist = 0.0f;
+	float clip_dist = 0.0f;
 
 	int xaxis = RNA_boolean_get(op->ptr, "xaxis");
 	int yaxis = RNA_boolean_get(op->ptr, "yaxis");
@@ -1616,7 +1616,7 @@ static int edbm_do_smooth_vertex_exec(bContext *C, wmOperator *op)
 				if (mmd->flag & MOD_MIR_AXIS_Z)
 					mirrz = TRUE;
 
-				clipdist = mmd->tolerance;
+				clip_dist = mmd->tolerance;
 			}
 		}
 	}
@@ -1627,9 +1627,9 @@ static int edbm_do_smooth_vertex_exec(bContext *C, wmOperator *op)
 	
 	for (i = 0; i < repeat; i++) {
 		if (!EDBM_op_callf(em, op,
-		                   "smooth_vert verts=%hv mirror_clip_x=%b mirror_clip_y=%b mirror_clip_z=%b clipdist=%f "
+		                   "smooth_vert verts=%hv mirror_clip_x=%b mirror_clip_y=%b mirror_clip_z=%b clip_dist=%f "
 		                   "use_axis_x=%b use_axis_y=%b use_axis_z=%b",
-		                   BM_ELEM_SELECT, mirrx, mirry, mirrz, clipdist, xaxis, yaxis, zaxis))
+		                   BM_ELEM_SELECT, mirrx, mirry, mirrz, clip_dist, xaxis, yaxis, zaxis))
 		{
 			return OPERATOR_CANCELLED;
 		}
@@ -1670,7 +1670,7 @@ static int edbm_do_smooth_laplacian_vertex_exec(bContext *C, wmOperator *op)
 {
 	Object *obedit = CTX_data_edit_object(C);
 	BMEditMesh *em = BMEdit_FromObject(obedit);
-	int usex = TRUE, usey = TRUE, usez = TRUE, volume_preservation = TRUE;
+	int usex = TRUE, usey = TRUE, usez = TRUE, preserve_volume = TRUE;
 	int i, repeat;
 	float lambda;
 	float lambda_border;
@@ -1698,14 +1698,14 @@ static int edbm_do_smooth_laplacian_vertex_exec(bContext *C, wmOperator *op)
 	usex = RNA_boolean_get(op->ptr, "use_x");
 	usey = RNA_boolean_get(op->ptr, "use_y");
 	usez = RNA_boolean_get(op->ptr, "use_z");
-	volume_preservation = RNA_boolean_get(op->ptr, "volume_preservation");
+	preserve_volume = RNA_boolean_get(op->ptr, "preserve_volume");
 	if (!repeat)
 		repeat = 1;
 	
 	for (i = 0; i < repeat; i++) {
 		if (!EDBM_op_callf(em, op,
-		                   "smooth_laplacian_vert verts=%hv lambda=%f lambda_border=%f use_x=%b use_y=%b use_z=%b volume_preservation=%b",
-		                   BM_ELEM_SELECT, lambda, lambda_border, usex, usey, usez, volume_preservation))
+		                   "smooth_laplacian_vert verts=%hv lambda=%f lambda_border=%f use_x=%b use_y=%b use_z=%b preserve_volume=%b",
+		                   BM_ELEM_SELECT, lambda, lambda_border, usex, usey, usez, preserve_volume))
 		{
 			return OPERATOR_CANCELLED;
 		}
@@ -1745,7 +1745,7 @@ void MESH_OT_vertices_smooth_laplacian(wmOperatorType *ot)
 	RNA_def_boolean(ot->srna, "use_x", 1, "Smooth X Axis", "Smooth object along	X axis");
 	RNA_def_boolean(ot->srna, "use_y", 1, "Smooth Y Axis", "Smooth object along	Y axis");
 	RNA_def_boolean(ot->srna, "use_z", 1, "Smooth Z Axis", "Smooth object along	Z axis");
-	RNA_def_boolean(ot->srna, "volume_preservation", 1, "Preserve Volume", "Apply volume preservation after smooth");
+	RNA_def_boolean(ot->srna, "preserve_volume", 1, "Preserve Volume", "Apply volume preservation after smooth");
 }
 
 /********************** Smooth/Solid Operators *************************/
@@ -1828,10 +1828,10 @@ static int edbm_rotate_uvs_exec(bContext *C, wmOperator *op)
 	BMOperator bmop;
 
 	/* get the direction from RNA */
-	int dir = RNA_enum_get(op->ptr, "direction");
+	const int use_ccw = RNA_boolean_get(op->ptr, "use_ccw");
 
 	/* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
-	EDBM_op_init(em, &bmop, op, "rotate_uvs faces=%hf dir=%i", BM_ELEM_SELECT, dir);
+	EDBM_op_init(em, &bmop, op, "rotate_uvs faces=%hf use_ccw=%b", BM_ELEM_SELECT, use_ccw);
 
 	/* execute the operator */
 	BMO_op_exec(em->bm, &bmop);
@@ -1877,10 +1877,10 @@ static int edbm_rotate_colors_exec(bContext *C, wmOperator *op)
 	BMOperator bmop;
 
 	/* get the direction from RNA */
-	int dir = RNA_enum_get(op->ptr, "direction");
+	const int use_ccw = RNA_boolean_get(op->ptr, "use_ccw");
 
 	/* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
-	EDBM_op_init(em, &bmop, op, "rotate_colors faces=%hf dir=%i", BM_ELEM_SELECT, dir);
+	EDBM_op_init(em, &bmop, op, "rotate_colors faces=%hf use_ccw=%b", BM_ELEM_SELECT, use_ccw);
 
 	/* execute the operator */
 	BMO_op_exec(em->bm, &bmop);
@@ -1936,7 +1936,7 @@ void MESH_OT_uvs_rotate(wmOperatorType *ot)
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
 	/* props */
-	RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CW, "Direction", "Direction to rotate UVs around");
+	RNA_def_boolean(ot->srna, "use_ccw", FALSE, "Counter Clockwise", "");
 }
 
 //void MESH_OT_uvs_mirror(wmOperatorType *ot)
@@ -1973,7 +1973,7 @@ void MESH_OT_colors_rotate(wmOperatorType *ot)
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
 	/* props */
-	RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CCW, "Direction", "Direction to rotate edge around");
+	RNA_def_boolean(ot->srna, "use_ccw", FALSE, "Counter Clockwise", "");
 }
 
 void MESH_OT_colors_reverse(wmOperatorType *ot)
@@ -2204,7 +2204,7 @@ static int edbm_remove_doubles_exec(bContext *C, wmOperator *op)
 		             BM_ELEM_SELECT, threshold);
 		BMO_op_exec(em->bm, &bmop);
 
-		if (!EDBM_op_callf(em, op, "weld_verts targetmap=%S", &bmop, "targetmapout")) {
+		if (!EDBM_op_callf(em, op, "weld_verts targetmap=%S", &bmop, "targetmap.out")) {
 			BMO_op_finish(em->bm, &bmop);
 			return OPERATOR_CANCELLED;
 		}
@@ -2313,7 +2313,7 @@ static int edbm_select_vertex_path_exec(bContext *C, wmOperator *op)
 	/* EDBM_flag_disable_all(em, BM_ELEM_SELECT); */
 
 	/* select the output */
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "vertout", BM_ALL, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "verts.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 
 	/* finish the operator */
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
@@ -2636,7 +2636,7 @@ static int edbm_solidify_exec(bContext *C, wmOperator *op)
 	BMO_op_exec(bm, &bmop);
 
 	/* select the newly generated faces */
-	BMO_slot_buffer_hflag_enable(bm, bmop.slots_out, "geomout", BM_FACE, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(bm, bmop.slots_out, "geom.out", BM_FACE, BM_ELEM_SELECT, TRUE);
 
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
@@ -2954,9 +2954,9 @@ static int edbm_knife_cut_exec(bContext *C, wmOperator *op)
 	BMO_slot_buffer_from_enabled_flag(bm, &bmop, bmop.slots_in, "edges", BM_EDGE, ELE_EDGE_CUT);
 
 	if (mode == KNIFE_MIDPOINT) numcuts = 1;
-	BMO_slot_int_set(bmop.slots_in, "numcuts", numcuts);
+	BMO_slot_int_set(bmop.slots_in, "cuts", numcuts);
 
-	BMO_slot_int_set(bmop.slots_in, "quadcornertype", SUBD_STRAIGHT_CUT);
+	BMO_slot_int_set(bmop.slots_in, "quad_corner_type", SUBD_STRAIGHT_CUT);
 	BMO_slot_bool_set(bmop.slots_in, "use_singleedge", FALSE);
 	BMO_slot_bool_set(bmop.slots_in, "use_gridfill", FALSE);
 
@@ -3303,7 +3303,7 @@ static int edbm_fill_exec(bContext *C, wmOperator *op)
 	BMO_op_exec(em->bm, &bmop);
 	
 	/* select new geometry */
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geomout", BM_FACE | BM_EDGE, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_FACE | BM_EDGE, BM_ELEM_SELECT, TRUE);
 	
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
@@ -3575,7 +3575,7 @@ static int edbm_split_exec(bContext *C, wmOperator *op)
 	EDBM_op_init(em, &bmop, op, "split geom=%hvef use_only_faces=%b", BM_ELEM_SELECT, FALSE);
 	BMO_op_exec(em->bm, &bmop);
 	BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE);
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geomout", BM_ALL, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
 	}
@@ -3630,14 +3630,14 @@ static int edbm_spin_exec(bContext *C, wmOperator *op)
 	mul_m3_v3(imat, axis);
 
 	if (!EDBM_op_init(em, &spinop, op,
-	                  "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i ang=%f do_dupli=%b",
+	                  "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i angle=%f use_duplicate=%b",
 	                  BM_ELEM_SELECT, cent, axis, d, steps, degr, dupli))
 	{
 		return OPERATOR_CANCELLED;
 	}
 	BMO_op_exec(bm, &spinop);
 	EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-	BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "lastout", BM_ALL, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "geom_last.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 	if (!EDBM_op_finish(em, &spinop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
 	}
@@ -3754,14 +3754,14 @@ static int edbm_screw_exec(bContext *C, wmOperator *op)
 		negate_v3(dvec);
 
 	if (!EDBM_op_init(em, &spinop, op,
-	                  "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i ang=%f do_dupli=%b",
+	                  "spin geom=%hvef cent=%v axis=%v dvec=%v steps=%i angle=%f use_duplicate=%b",
 	                  BM_ELEM_SELECT, cent, axis, dvec, turns * steps, 360.0f * turns, FALSE))
 	{
 		return OPERATOR_CANCELLED;
 	}
 	BMO_op_exec(bm, &spinop);
 	EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-	BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "lastout", BM_ALL, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(bm, spinop.slots_out, "geom_last.out", BM_ALL, BM_ELEM_SELECT, TRUE);
 	if (!EDBM_op_finish(em, &spinop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
 	}
@@ -4771,7 +4771,7 @@ static int edbm_bevel_calc(bContext *C, wmOperator *op)
 		/* not essential, but we may have some loose geometry that
 		 * won't get bevel'd and better not leave it selected */
 		EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-		BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
+		BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, TRUE);
 	}
 
 #else
@@ -5105,7 +5105,7 @@ static int edbm_bridge_edge_loops_exec(bContext *C, wmOperator *op)
 	/* when merge is used the edges are joined and remain selected */
 	if (use_merge == FALSE) {
 		EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-		BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
+		BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, TRUE);
 	}
 
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
@@ -5278,11 +5278,11 @@ static int edbm_inset_calc(bContext *C, wmOperator *op)
 	if (use_select_inset) {
 		/* deselect original faces/verts */
 		EDBM_flag_disable_all(em, BM_ELEM_SELECT);
-		BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
+		BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, TRUE);
 	}
 	else {
 		BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE, BM_ELEM_SELECT, FALSE);
-		BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "faceout", BM_FACE, BM_ELEM_SELECT, FALSE);
+		BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, FALSE);
 		/* re-select faces so the verts and edges get selected too */
 		BM_mesh_elem_hflag_enable_test(em->bm, BM_FACE, BM_ELEM_SELECT, TRUE, BM_ELEM_SELECT);
 	}
@@ -5547,7 +5547,7 @@ static int edbm_wireframe_exec(bContext *C, wmOperator *op)
 	}
 
 	BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE);
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faceout", BM_FACE, BM_ELEM_SELECT, TRUE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, TRUE);
 
 	if (!EDBM_op_finish(em, &bmop, op, TRUE)) {
 		return OPERATOR_CANCELLED;
@@ -5611,7 +5611,7 @@ static int edbm_convex_hull_exec(bContext *C, wmOperator *op)
 	/* Delete unused vertices, edges, and faces */
 	if (RNA_boolean_get(op->ptr, "delete_unused")) {
 		if (!EDBM_op_callf(em, op, "delete geom=%S context=%i",
-		                   &bmop, "unused_geom_out", DEL_ONLYTAGGED))
+		                   &bmop, "geom_unused.out", DEL_ONLYTAGGED))
 		{
 			EDBM_op_finish(em, &bmop, op, TRUE);
 			return OPERATOR_CANCELLED;
@@ -5621,7 +5621,7 @@ static int edbm_convex_hull_exec(bContext *C, wmOperator *op)
 	/* Delete hole edges/faces */
 	if (RNA_boolean_get(op->ptr, "make_holes")) {
 		if (!EDBM_op_callf(em, op, "delete geom=%S context=%i",
-		                   &bmop, "holes_geom_out", DEL_ONLYTAGGED))
+		                   &bmop, "geom_holes.out", DEL_ONLYTAGGED))
 		{
 			EDBM_op_finish(em, &bmop, op, TRUE);
 			return OPERATOR_CANCELLED;
@@ -5631,7 +5631,7 @@ static int edbm_convex_hull_exec(bContext *C, wmOperator *op)
 	/* Merge adjacent triangles */
 	if (RNA_boolean_get(op->ptr, "join_triangles")) {
 		if (!EDBM_op_callf(em, op, "join_triangles faces=%S limit=%f",
-		                   &bmop, "geomout",
+		                   &bmop, "geom.out",
 		                   RNA_float_get(op->ptr, "limit")))
 		{
 			EDBM_op_finish(em, &bmop, op, TRUE);
diff --git a/source/blender/editors/mesh/editmesh_utils.c b/source/blender/editors/mesh/editmesh_utils.c
index e5f645ada21..22c71d5d3ca 100644
--- a/source/blender/editors/mesh/editmesh_utils.c
+++ b/source/blender/editors/mesh/editmesh_utils.c
@@ -494,11 +494,11 @@ void EDBM_select_more(BMEditMesh *em)
 	int use_faces = em->selectmode == SCE_SELECT_FACE;
 
 	BMO_op_initf(em->bm, &bmop, BMO_FLAG_DEFAULTS,
-	             "region_extend geom=%hvef constrict=%b use_faces=%b",
+	             "region_extend geom=%hvef use_constrict=%b use_faces=%b",
 	             BM_ELEM_SELECT, FALSE, use_faces);
 	BMO_op_exec(em->bm, &bmop);
 	/* don't flush selection in edge/vertex mode  */
-	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geomout", BM_ALL, BM_ELEM_SELECT, use_faces ? TRUE : FALSE);
+	BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "geom.out", BM_ALL, BM_ELEM_SELECT, use_faces ? TRUE : FALSE);
 	BMO_op_finish(em->bm, &bmop);
 
 	EDBM_select_flush(em);
@@ -510,11 +510,11 @@ void EDBM_select_less(BMEditMesh *em)
 	int use_faces = em->selectmode == SCE_SELECT_FACE;
 
 	BMO_op_initf(em->bm, &bmop, BMO_FLAG_DEFAULTS,
-	             "region_extend geom=%hvef constrict=%b use_faces=%b",
+	             "region_extend geom=%hvef use_constrict=%b use_faces=%b",
 	             BM_ELEM_SELECT, TRUE, use_faces);
 	BMO_op_exec(em->bm, &bmop);
 	/* don't flush selection in edge/vertex mode  */
-	BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "geomout", BM_ALL, BM_ELEM_SELECT, use_faces ? TRUE : FALSE);
+	BMO_slot_buffer_hflag_disable(em->bm, bmop.slots_out, "geom.out", BM_ALL, BM_ELEM_SELECT, use_faces ? TRUE : FALSE);
 	BMO_op_finish(em->bm, &bmop);
 
 	EDBM_selectmode_flush(em);
diff --git a/source/blender/makesdna/DNA_modifier_types.h b/source/blender/makesdna/DNA_modifier_types.h
index 7078ee0d51c..3875a0d5799 100644
--- a/source/blender/makesdna/DNA_modifier_types.h
+++ b/source/blender/makesdna/DNA_modifier_types.h
@@ -1131,7 +1131,7 @@ enum {
 #define MOD_LAPLACIANSMOOTH_X (1<<1)
 #define MOD_LAPLACIANSMOOTH_Y (1<<2)
 #define MOD_LAPLACIANSMOOTH_Z (1<<3)
-#define MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION (1<<4)
+#define MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME (1 << 4)
 
 typedef struct LaplacianSmoothModifierData {
 	ModifierData modifier;
diff --git a/source/blender/makesrna/intern/rna_modifier.c b/source/blender/makesrna/intern/rna_modifier.c
index a9a1d81077b..06df6c5afbc 100644
--- a/source/blender/makesrna/intern/rna_modifier.c
+++ b/source/blender/makesrna/intern/rna_modifier.c
@@ -1817,7 +1817,7 @@ static void rna_def_modifier_laplaciansmooth(BlenderRNA *brna)
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
 	prop = RNA_def_property(srna, "use_volume_preserve", PROP_BOOLEAN, PROP_NONE);
-	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME);
 	RNA_def_property_ui_text(prop, "Preserve Volume", "Apply volume preservation after smooth");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
diff --git a/source/blender/modifiers/intern/MOD_array.c b/source/blender/modifiers/intern/MOD_array.c
index d9526199d16..4921c5e3585 100644
--- a/source/blender/modifiers/intern/MOD_array.c
+++ b/source/blender/modifiers/intern/MOD_array.c
@@ -185,7 +185,7 @@ static int *find_doubles_index_map(BMesh *bm, BMOperator *dupe_op,
 		i++;
 	}
 
-	BMO_ITER (ele, &oiter, dupe_op->slots_out, "newout", BM_ALL) {
+	BMO_ITER (ele, &oiter, dupe_op->slots_out, "geom.out", BM_ALL) {
 		BM_elem_index_set(ele, i); /* set_dirty */
 		i++;
 	}
@@ -197,7 +197,7 @@ static int *find_doubles_index_map(BMesh *bm, BMOperator *dupe_op,
 	index_map = MEM_callocN(sizeof(int) * (*index_map_length), "index_map");
 
 	/*element type argument doesn't do anything here*/
-	BMO_ITER (v, &oiter, find_op.slots_out, "targetmapout", 0) {
+	BMO_ITER (v, &oiter, find_op.slots_out, "targetmap.out", 0) {
 		v2 = BMO_iter_map_value_p(&oiter);
 
 		index_map[BM_elem_index_get(v)] = BM_elem_index_get(v2) + 1;
@@ -267,7 +267,7 @@ static void bm_merge_dm_transform(BMesh *bm, DerivedMesh *dm, float mat[4][4],
 		BMO_op_exec(bm, &find_op);
 
 		/* add new merge targets to weld operator */
-		BMO_ITER (v, &oiter, find_op.slots_out, "targetmapout", 0) {
+		BMO_ITER (v, &oiter, find_op.slots_out, "targetmap.out", 0) {
 			v2 = BMO_iter_map_value_p(&oiter);
 			/* check in case the target vertex (v2) is already marked
 			 * for merging */
@@ -307,12 +307,12 @@ static void merge_first_last(BMesh *bm,
 
 	/* append the last dupe's geom to the findop input verts */
 	BMO_slot_buffer_append(&find_op,  slots_in,  "verts",
-	                       dupe_last, slots_out, "newout");
+	                       dupe_last, slots_out, "geom.out");
 
 	BMO_op_exec(bm, &find_op);
 
 	/* add new merge targets to weld operator */
-	BMO_ITER (v, &oiter, find_op.slots_out, "targetmapout", 0) {
+	BMO_ITER (v, &oiter, find_op.slots_out, "targetmap.out", 0) {
 		v2 = BMO_iter_map_value_p(&oiter);
 		BMO_slot_map_ptr_insert(weld_op, weld_op->slots_in, "targetmap", v, v2);
 	}
@@ -437,18 +437,18 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 	for (j = 0; j < count - 1; j++) {
 		BMVert *v, *v2, *v3;
 		BMOpSlot *geom_slot;
-		BMOpSlot *newout_slot;
+		BMOpSlot *geom_out_slot;
 		BMOIter oiter;
 
 		if (j != 0) {
 			BMO_op_initf(bm, &dupe_op,
 			             (BMO_FLAG_DEFAULTS & ~BMO_FLAG_RESPECT_HIDE),
-			             "duplicate geom=%S", &old_dupe_op, "newout");
+			             "duplicate geom=%S", &old_dupe_op, "geom.out");
 		}
 		BMO_op_exec(bm, &dupe_op);
 
 		geom_slot   = BMO_slot_get(dupe_op.slots_in,  "geom");
-		newout_slot = BMO_slot_get(dupe_op.slots_out, "newout");
+		geom_out_slot = BMO_slot_get(dupe_op.slots_out, "geom.out");
 
 		if ((amd->flags & MOD_ARR_MERGEFINAL) && j == 0) {
 			int first_geom_bytes = sizeof(BMVert *) * geom_slot->len;
@@ -460,7 +460,7 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 		}
 
 		/* apply transformation matrix */
-		BMO_ITER (v, &oiter, dupe_op.slots_out, "newout", BM_VERT) {
+		BMO_ITER (v, &oiter, dupe_op.slots_out, "geom.out", BM_VERT) {
 			mul_m4_v3(offset, v->co);
 		}
 
@@ -479,8 +479,8 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 			for (i = 0; i < index_len; i++) {
 				if (!indexMap[i]) continue;
 
-				/* merge v (from 'newout') into v2 (from old 'geom') */
-				v = _E(newout_slot, i - geom_slot->len);
+				/* merge v (from 'geom.out') into v2 (from old 'geom') */
+				v = _E(geom_out_slot, i - geom_slot->len);
 				v2 = _E(geom_slot, indexMap[i] - 1);
 
 				/* check in case the target vertex (v2) is already marked
@@ -533,7 +533,7 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 			mult_m4_m4m4(endoffset, offset, final_offset);
 			bm_merge_dm_transform(bm, end_cap, endoffset, amd,
 			                      &dupe_op, (count == 1) ? dupe_op.slots_in : dupe_op.slots_out,
-			                      (count == 1) ? "geom" : "newout", &weld_op);
+			                      (count == 1) ? "geom" : "geom.out", &weld_op);
 		}
 	}
 	/* done capping */
diff --git a/source/blender/modifiers/intern/MOD_laplaciansmooth.c b/source/blender/modifiers/intern/MOD_laplaciansmooth.c
index 6f6589d4d14..266226040a3 100644
--- a/source/blender/modifiers/intern/MOD_laplaciansmooth.c
+++ b/source/blender/modifiers/intern/MOD_laplaciansmooth.c
@@ -199,7 +199,7 @@ static void init_data(ModifierData *md)
 	smd->lambda = 0.00001f;
 	smd->lambda_border = 0.00005f;
 	smd->repeat = 1;
-	smd->flag = MOD_LAPLACIANSMOOTH_X | MOD_LAPLACIANSMOOTH_Y | MOD_LAPLACIANSMOOTH_Z | MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION;
+	smd->flag = MOD_LAPLACIANSMOOTH_X | MOD_LAPLACIANSMOOTH_Y | MOD_LAPLACIANSMOOTH_Z | MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME;
 	smd->defgrp_name[0] = '\0';
 }
 
@@ -511,7 +511,7 @@ static void validate_solution(LaplacianSystem *sys, short flag)
 	float leni, lene;
 	float vini, vend;
 	float *vi1, *vi2, ve1[3], ve2[3];
-	if (flag & MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION) {
+	if (flag & MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME) {
 		vini = compute_volume(sys->vertexCos, sys->mfaces, sys->numFaces);
 	}
 	for (i = 0; i < sys->numEdges; i++) {
@@ -545,7 +545,7 @@ static void validate_solution(LaplacianSystem *sys, short flag)
 			}
 		}
 	}
-	if (flag & MOD_LAPLACIANSMOOTH_VOLUME_PRESERVATION) {
+	if (flag & MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME) {
 		vend = compute_volume(sys->vertexCos, sys->mfaces, sys->numFaces);
 		volume_preservation(sys, vini, vend, flag);
 	}
diff --git a/source/blender/modifiers/intern/MOD_skin.c b/source/blender/modifiers/intern/MOD_skin.c
index cc2405ed186..5e6c178762a 100644
--- a/source/blender/modifiers/intern/MOD_skin.c
+++ b/source/blender/modifiers/intern/MOD_skin.c
@@ -249,14 +249,14 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
 	}
 
 	/* Apply face attributes to hull output */
-	BMO_ITER (f, &oiter, op.slots_out, "geomout", BM_FACE) {
+	BMO_ITER (f, &oiter, op.slots_out, "geom.out", BM_FACE) {
 		if (so->smd->flag & MOD_SKIN_SMOOTH_SHADING)
 			BM_elem_flag_enable(f, BM_ELEM_SMOOTH);
 		f->mat_nr = so->mat_nr;
 	}
 
 	/* Mark interior frames */
-	BMO_ITER (v, &oiter, op.slots_out, "interior_geom_out", BM_VERT) {
+	BMO_ITER (v, &oiter, op.slots_out, "geom_interior.out", BM_VERT) {
 		for (i = 0; i < totframe; i++) {
 			Frame *frame = frames[i];
 			
@@ -309,7 +309,7 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
 
 	/* Check if removing triangles above will create wire triangles,
 	 * mark them too */
-	BMO_ITER (e, &oiter, op.slots_out, "geomout", BM_EDGE) {
+	BMO_ITER (e, &oiter, op.slots_out, "geom.out", BM_EDGE) {
 		int is_wire = TRUE;
 		BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) {
 			if (!BM_elem_flag_test(f, BM_ELEM_TAG)) {
@@ -1229,7 +1229,7 @@ static void skin_fix_hole_no_good_verts(BMesh *bm, Frame *frame, BMFace *split_f
 	/* Update split face (should only be one new face created
 	 * during extrusion) */
 	split_face = NULL;
-	BMO_ITER (f, &oiter, op.slots_out, "faceout", BM_FACE) {
+	BMO_ITER (f, &oiter, op.slots_out, "faces.out", BM_FACE) {
 		BLI_assert(!split_face);
 		split_face = f;
 	}
@@ -1247,7 +1247,7 @@ static void skin_fix_hole_no_good_verts(BMesh *bm, Frame *frame, BMFace *split_f
 		BM_elem_flag_enable(longest_edge, BM_ELEM_TAG);
 
 		BMO_op_callf(bm, BMO_FLAG_DEFAULTS,
-		             "subdivide_edges edges=%he numcuts=%i quadcornertype=%i",
+		             "subdivide_edges edges=%he cuts=%i quad_corner_type=%i",
 		             BM_ELEM_TAG, 1, SUBD_STRAIGHT_CUT);
 	}
 	else if (split_face->len > 4) {