remove BM_ITER, BM_ITER_INDEX macros, use ELEM or MESH variants only (the maceros...
[blender-staging.git] / source / blender / bmesh / intern / bmesh_operators.c
index d49887a87f032e6c0824a42f11771e9cea627033..dce491efe72a4aab3487953bf54af6f535578248 100644 (file)
 #include "BLI_array.h"
 
 #include "bmesh.h"
-#include "bmesh_private.h"
-#include "stdarg.h"
-
-#include <string.h>
+#include "intern/bmesh_private.h"
 
 /* forward declarations */
-static void alloc_flag_layer(BMesh *bm);
-static void free_flag_layer(BMesh *bm);
-static void clear_flag_layer(BMesh *bm);
-static int bmesh_name_to_slotcode(BMOpDefine *def, const char *name);
-static int bmesh_name_to_slotcode_check(BMOpDefine *def, const char *name);
-static int bmesh_opname_to_opcode(const char *opname);
-
-static const char *bmop_error_messages[] = {
-       NULL,
-       "Self intersection error",
-       "Could not dissolve vert",
-       "Could not connect vertices",
-       "Could not traverse mesh",
-       "Could not dissolve faces",
-       "Could not dissolve vertices",
-       "Tesselation error",
-       "Can not deal with non-manifold geometry",
-       "Invalid selection",
-          "Internal mesh error",
+static void bmo_flag_layer_alloc(BMesh *bm);
+static void bmo_flag_layer_free(BMesh *bm);
+static void bmo_flag_layer_clear(BMesh *bm);
+static int bmo_name_to_slotcode(BMOpDefine *def, const char *name);
+static int bmo_name_to_slotcode_check(BMOpDefine *def, const char *name);
+static int bmo_opname_to_opcode(const char *opname);
+
+static const char *bmo_error_messages[] = {
+       NULL,
+       "Self intersection error",
+       "Could not dissolve vert",
+       "Could not connect vertices",
+       "Could not traverse mesh",
+       "Could not dissolve faces",
+       "Could not dissolve vertices",
+       "Tessellation error",
+       "Can not deal with non-manifold geometry",
+       "Invalid selection",
+       "Internal mesh error",
 };
 
 
 /* operator slot type information - size of one element of the type given. */
-const int BMOP_OPSLOT_TYPEINFO[] = {
-       0,
-       sizeof(int),
-       sizeof(float),
-       sizeof(void *),
-       0, /* unused */
-       0, /* unused */
-       0, /* unused */
-       sizeof(void *), /* pointer buffer */
-       sizeof(element_mapping)
+const int BMO_OPSLOT_TYPEINFO[BMO_OP_SLOT_TOTAL_TYPES] = {
+       0,                      /*  0: BMO_OP_SLOT_SENTINEL */
+       sizeof(int),            /*  1: BMO_OP_SLOT_BOOL */ 
+       sizeof(int),            /*  2: BMO_OP_SLOT_INT */ 
+       sizeof(float),          /*  3: BMO_OP_SLOT_FLT */ 
+       sizeof(void *),         /*  4: BMO_OP_SLOT_PNT */ 
+       sizeof(void *),         /*  5: BMO_OP_SLOT_PNT */
+       0,                      /*  6: unused */
+       0,                      /*  7: unused */
+       sizeof(float) * 3,      /*  8: BMO_OP_SLOT_VEC */
+       sizeof(void *),         /*  9: BMO_OP_SLOT_ELEMENT_BUF */
+       sizeof(BMOElemMapping)  /* 10: BMO_OP_SLOT_MAPPING */
 };
 
 /* Dummy slot so there is something to return when slot name lookup fails */
-static BMOpSlot BMOpEmptySlot = { 0 };
+static BMOpSlot BMOpEmptySlot = {0};
 
-void BMO_Set_OpFlag(BMesh *UNUSED(bm), BMOperator *op, int flag)
+void BMO_op_flag_enable(BMesh *UNUSED(bm), BMOperator *op, const int op_flag)
 {
-       op->flag |= flag;
+       op->flag |= op_flag;
 }
 
-void BMO_Clear_OpFlag(BMesh *UNUSED(bm), BMOperator *op, int flag)
+void BMO_op_flag_disable(BMesh *UNUSED(bm), BMOperator *op, const int op_flag)
 {
-       op->flag &= ~flag;
+       op->flag &= ~op_flag;
 }
 
-/*
- * BMESH OPSTACK PUSH
+/**
+ * \brief BMESH OPSTACK PUSH
  *
- * Pushes the opstack down one level 
- * and allocates a new flag layer if
- * appropriate.
+ * Pushes the opstack down one level and allocates a new flag layer if appropriate.
  */
 void BMO_push(BMesh *bm, BMOperator *UNUSED(op))
 {
@@ -104,36 +101,34 @@ void BMO_push(BMesh *bm, BMOperator *UNUSED(op))
 
        /* add flag layer, if appropriate */
        if (bm->stackdepth > 1)
-               alloc_flag_layer(bm);
+               bmo_flag_layer_alloc(bm);
        else
-               clear_flag_layer(bm);
+               bmo_flag_layer_clear(bm);
 }
 
-/*
- * BMESH OPSTACK POP
+/**
+ * \brief BMESH OPSTACK POP
+ *
+ * Pops the opstack one level and frees a flag layer if appropriate
  *
- * Pops the opstack one level  
- * and frees a flag layer if appropriate
- * BMESH_TODO: investigate NOT freeing flag
- * layers.
+ * BMESH_TODO: investigate NOT freeing flag layers.
  */
 void BMO_pop(BMesh *bm)
 {
        if (bm->stackdepth > 1)
-               free_flag_layer(bm);
+               bmo_flag_layer_free(bm);
 
        bm->stackdepth--;
 }
 
-/*
- * BMESH OPSTACK INIT OP
+/**
+ * \brief BMESH OPSTACK INIT OP
  *
- * Initializes an operator structure  
- * to a certain type
+ * Initializes an operator structure to a certain type
  */
-void BMO_Init_Op(BMesh *bm, BMOperator *op, const char *opname)
+void BMO_op_init(BMesh *bm, BMOperator *op, const char *opname)
 {
-       int i, opcode = bmesh_opname_to_opcode(opname);
+       int i, opcode = bmo_opname_to_opcode(opname);
 
 #ifdef DEBUG
        BM_ELEM_INDEX_VALIDATE(bm, "pre bmo", opname);
@@ -159,49 +154,48 @@ void BMO_Init_Op(BMesh *bm, BMOperator *op, const char *opname)
        op->exec = opdefines[opcode]->exec;
 
        /* memarena, used for operator's slot buffers */
-       op->arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "bmesh operator");
-       BLI_memarena_use_calloc (op->arena);
+       op->arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
+       BLI_memarena_use_calloc(op->arena);
 }
 
-/*
- * BMESH OPSTACK EXEC OP
+/**
+ * \brief BMESH OPSTACK EXEC OP
  *
- * Executes a passed in operator. This handles
- * the allocation and freeing of temporary flag
- * layers and starting/stopping the modelling
- * loop. Can be called from other operators
- * exec callbacks as well.
+ * Executes a passed in operator.
+ *
+ * This handles the allocation and freeing of temporary flag
+ * layers and starting/stopping the modeling loop.
+ * Can be called from other operators exec callbacks as well.
  */
-void BMO_Exec_Op(BMesh *bm, BMOperator *op)
+void BMO_op_exec(BMesh *bm, BMOperator *op)
 {
        
        BMO_push(bm, op);
 
        if (bm->stackdepth == 2)
-               bmesh_begin_edit(bm, op->flag);
+               bmesh_edit_begin(bm, op->flag);
        op->exec(bm, op);
        
        if (bm->stackdepth == 2)
-               bmesh_end_edit(bm, op->flag);
+               bmesh_edit_end(bm, op->flag);
        
-       BMO_pop(bm);    
+       BMO_pop(bm);
 }
 
-/*
- * BMESH OPSTACK FINISH OP
+/**
+ * \brief BMESH OPSTACK FINISH OP
  *
- * Does housekeeping chores related to finishing
- * up an operator.
+ * Does housekeeping chores related to finishing up an operator.
  */
-void BMO_Finish_Op(BMesh *bm, BMOperator *op)
+void BMO_op_finish(BMesh *bm, BMOperator *op)
 {
        BMOpSlot *slot;
        int i;
 
        for (i = 0; opdefines[op->type]->slottypes[i].type; i++) {
                slot = &op->slots[i];
-               if (slot->slottype == BMOP_OPSLOT_MAPPING) {
-                       if (slot->data.ghash) 
+               if (slot->slottype == BMO_OP_SLOT_MAPPING) {
+                       if (slot->data.ghash)
                                BLI_ghash_free(slot->data.ghash, NULL, NULL);
                }
        }
@@ -215,27 +209,25 @@ void BMO_Finish_Op(BMesh *bm, BMOperator *op)
 #endif
 }
 
-/*
- * BMESH OPSTACK HAS SLOT
+/**
+ * \brief BMESH OPSTACK HAS SLOT
  *
- * Returns 1 if the named slot exists on the given operator,
- * otherwise returns 0.
+ * \return Success if the slot if found.
  */
-int BMO_HasSlot(BMOperator *op, const char *slotname)
+int BMO_slot_exists(BMOperator *op, const char *slotname)
 {
-       int slotcode = bmesh_name_to_slotcode(opdefines[op->type], slotname);
+       int slotcode = bmo_name_to_slotcode(opdefines[op->type], slotname);
        return (slotcode >= 0);
 }
 
-/*
- * BMESH OPSTACK GET SLOT
+/**
+ * \brief BMESH OPSTACK GET SLOT
  *
- * Returns a pointer to the slot of  
- * type 'slotcode'
+ * Returns a pointer to the slot of type 'slotcode'
  */
-BMOpSlot *BMO_GetSlot(BMOperator *op, const char *slotname)
+BMOpSlot *BMO_slot_get(BMOperator *op, const char *slotname)
 {
-       int slotcode = bmesh_name_to_slotcode_check(opdefines[op->type], slotname);
+       int slotcode = bmo_name_to_slotcode_check(opdefines[op->type], slotname);
 
        if (slotcode < 0) {
                return &BMOpEmptySlot;
@@ -244,60 +236,58 @@ BMOpSlot *BMO_GetSlot(BMOperator *op, const char *slotname)
        return &(op->slots[slotcode]);
 }
 
-/*
- * BMESH OPSTACK COPY SLOT
+/**
+ * \brief BMESH OPSTACK COPY SLOT
  *
- * Copies data from one slot to another
+ * Copies data from one slot to another.
  */
-void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, const char *dst)
+void BMO_slot_copy(BMOperator *source_op, BMOperator *dest_op, const char *src, const char *dst)
 {
-       BMOpSlot *source_slot = BMO_GetSlot(source_op, src);
-       BMOpSlot *dest_slot = BMO_GetSlot(dest_op, dst);
+       BMOpSlot *source_slot = BMO_slot_get(source_op, src);
+       BMOpSlot *dest_slot = BMO_slot_get(dest_op, dst);
 
        if (source_slot == dest_slot)
                return;
 
-       if (source_slot->slottype != dest_slot->slottype)
+       if (source_slot->slottype != dest_slot->slottype) {
+               /* possibly assert here? */
                return;
-       
-       if (dest_slot->slottype > BMOP_OPSLOT_VEC) {
-               if (dest_slot->slottype != BMOP_OPSLOT_MAPPING) {
-                       /* do buffer copy */
-                       dest_slot->data.buf = NULL;
-                       dest_slot->len = source_slot->len;
-                       if (dest_slot->len) {
-                               const int slot_alloc_size = BMOP_OPSLOT_TYPEINFO[dest_slot->slottype] * dest_slot->len;
-                               dest_slot->data.buf = BLI_memarena_alloc(dest_op->arena, slot_alloc_size);
-                               memcpy(dest_slot->data.buf, source_slot->data.buf, slot_alloc_size);
-                       }
+       }
+
+       if (dest_slot->slottype  == BMO_OP_SLOT_ELEMENT_BUF) {
+               /* do buffer copy */
+               dest_slot->data.buf = NULL;
+               dest_slot->len = source_slot->len;
+               if (dest_slot->len) {
+                       const int slot_alloc_size = BMO_OPSLOT_TYPEINFO[dest_slot->slottype] * dest_slot->len;
+                       dest_slot->data.buf = BLI_memarena_alloc(dest_op->arena, slot_alloc_size);
+                       memcpy(dest_slot->data.buf, source_slot->data.buf, slot_alloc_size);
                }
-               else {
-                       GHashIterator it;
-                       element_mapping *srcmap, *dstmap;
+       }
+       else if (dest_slot->slottype  == BMO_OP_SLOT_MAPPING) {
+               GHashIterator it;
+               BMOElemMapping *srcmap, *dstmap;
 
-                       /* sanity check */
-                       if (!source_slot->data.ghash) return;
-                       
-                       if (!dest_slot->data.ghash) {
-                               dest_slot->data.ghash = 
-                                     BLI_ghash_new(BLI_ghashutil_ptrhash, 
-                                         BLI_ghashutil_ptrcmp, "bmesh operator 2");
-                       }
+               /* sanity check */
+               if (!source_slot->data.ghash) {
+                       return;
+               }
 
-                       BLI_ghashIterator_init(&it, source_slot->data.ghash);
-                       for ( ; (srcmap = BLI_ghashIterator_getValue(&it));
-                             BLI_ghashIterator_step(&it))
-                       {
-                               dstmap = BLI_memarena_alloc(dest_op->arena, 
-                                           sizeof(*dstmap) + srcmap->len);
+               if (!dest_slot->data.ghash) {
+                       dest_slot->data.ghash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh operator 2");
+               }
 
-                               dstmap->element = srcmap->element;
-                               dstmap->len = srcmap->len;
-                               memcpy(dstmap + 1, srcmap + 1, srcmap->len);
+               BLI_ghashIterator_init(&it, source_slot->data.ghash);
+               for ( ; (srcmap = BLI_ghashIterator_getValue(&it));
+                         BLI_ghashIterator_step(&it))
+               {
+                       dstmap = BLI_memarena_alloc(dest_op->arena, sizeof(*dstmap) + srcmap->len);
 
-                               BLI_ghash_insert(dest_slot->data.ghash,
-                                                dstmap->element, dstmap);
-                       }
+                       dstmap->element = srcmap->element;
+                       dstmap->len = srcmap->len;
+                       memcpy(dstmap + 1, srcmap + 1, srcmap->len);
+
+                       BLI_ghash_insert(dest_slot->data.ghash, dstmap->element, dstmap);
                }
        }
        else {
@@ -309,32 +299,44 @@ void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, c
  * BMESH OPSTACK SET XXX
  *
  * Sets the value of a slot depending on it's type
- *
  */
 
-void BMO_Set_Float(BMOperator *op, const char *slotname, float f)
+void BMO_slot_float_set(BMOperator *op, const char *slotname, const float f)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_FLT))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_FLT);
+       if (!(slot->slottype == BMO_OP_SLOT_FLT))
                return;
 
        slot->data.f = f;
 }
 
-void BMO_Set_Int(BMOperator *op, const char *slotname, int i)
+void BMO_slot_int_set(BMOperator *op, const char *slotname, const int i)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_INT))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_INT);
+       if (!(slot->slottype == BMO_OP_SLOT_INT))
+               return;
+
+       slot->data.i = i;
+}
+
+void BMO_slot_bool_set(BMOperator *op, const char *slotname, const int i)
+{
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_BOOL);
+       if (!(slot->slottype == BMO_OP_SLOT_BOOL))
                return;
 
        slot->data.i = i;
 }
 
 /* only supports square mats */
-void BMO_Set_Mat(struct BMOperator *op, const char *slotname, float *mat, int size)
+void BMO_slot_mat_set(BMOperator *op, const char *slotname, const float *mat, int size)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_MAT))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_MAT);
+       if (!(slot->slottype == BMO_OP_SLOT_MAT))
                return;
 
        slot->len = 4;
@@ -350,79 +352,96 @@ void BMO_Set_Mat(struct BMOperator *op, const char *slotname, float *mat, int si
                fprintf(stderr, "%s: invalid size argument %d (bmesh internal error)\n", __func__, size);
 
                memset(slot->data.p, 0, sizeof(float) * 4 * 4);
-               return;
        }
 }
 
-void BMO_Get_Mat4(struct BMOperator *op, const char *slotname, float mat[4][4])
+void BMO_slot_mat4_get(BMOperator *op, const char *slotname, float r_mat[4][4])
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_MAT))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_MAT);
+       if (!(slot->slottype == BMO_OP_SLOT_MAT))
                return;
 
-       memcpy(mat, slot->data.p, sizeof(float) * 4 * 4);
+       copy_m4_m4(r_mat, (float (*)[4])slot->data.p);
 }
 
-void BMO_Get_Mat3(struct BMOperator *op, const char *slotname, float mat[3][3])
+void BMO_slot_mat3_set(BMOperator *op, const char *slotname, float r_mat[3][3])
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_MAT))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_MAT);
+       if (!(slot->slottype == BMO_OP_SLOT_MAT))
                return;
 
-       copy_m3_m4(mat, slot->data.p);
+       copy_m3_m4(r_mat, slot->data.p);
 }
 
-void BMO_Set_Pnt(BMOperator *op, const char *slotname, void *p)
+void BMO_slot_ptr_set(BMOperator *op, const char *slotname, void *p)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_PNT))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_PNT);
+       if (!(slot->slottype == BMO_OP_SLOT_PNT))
                return;
 
        slot->data.p = p;
 }
 
-void BMO_Set_Vec(BMOperator *op, const char *slotname, const float vec[3])
+void BMO_slot_vec_set(BMOperator *op, const char *slotname, const float vec[3])
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_VEC))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_VEC);
+       if (!(slot->slottype == BMO_OP_SLOT_VEC))
                return;
 
        copy_v3_v3(slot->data.vec, vec);
 }
 
 
-float BMO_Get_Float(BMOperator *op, const char *slotname)
+float BMO_slot_float_get(BMOperator *op, const char *slotname)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_FLT))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_FLT);
+       if (!(slot->slottype == BMO_OP_SLOT_FLT))
                return 0.0f;
 
        return slot->data.f;
 }
 
-int BMO_Get_Int(BMOperator *op, const char *slotname)
+int BMO_slot_int_get(BMOperator *op, const char *slotname)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_INT))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_INT);
+       if (!(slot->slottype == BMO_OP_SLOT_INT))
+               return 0;
+
+       return slot->data.i;
+}
+
+int BMO_slot_bool_get(BMOperator *op, const char *slotname)
+{
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_BOOL);
+       if (!(slot->slottype == BMO_OP_SLOT_BOOL))
                return 0;
 
        return slot->data.i;
 }
 
 
-void *BMO_Get_Pnt(BMOperator *op, const char *slotname)
+void *BMO_slot_ptr_get(BMOperator *op, const char *slotname)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_PNT))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_PNT);
+       if (!(slot->slottype == BMO_OP_SLOT_PNT))
                return NULL;
 
        return slot->data.p;
 }
 
-void BMO_Get_Vec(BMOperator *op, const char *slotname, float r_vec[3])
+void BMO_slot_vec_get(BMOperator *op, const char *slotname, float r_vec[3])
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       if (!(slot->slottype == BMOP_OPSLOT_VEC))
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_VEC);
+       if (!(slot->slottype == BMO_OP_SLOT_VEC))
                return;
 
        copy_v3_v3(r_vec, slot->data.vec);
@@ -431,95 +450,140 @@ void BMO_Get_Vec(BMOperator *op, const char *slotname, float r_vec[3])
 /*
  * BMO_COUNTFLAG
  *
- * Counts the number of elements of a certain type that
- * have a specific flag set.
+ * Counts the number of elements of a certain type that have a
+ * specific flag enabled (or disabled if test_for_enabled is false).
  *
  */
 
-int BMO_CountFlag(BMesh *bm, int flag, const char htype)
+static int bmo_mesh_flag_count(BMesh *bm, const char htype, const short oflag,
+                               const short test_for_enabled)
 {
-       BMIter elements;
-       BMHeader *e;
+       const char iter_types[3] = {BM_VERTS_OF_MESH,
+                                   BM_EDGES_OF_MESH,
+                                   BM_FACES_OF_MESH};
+
+       const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE};
+
+       BMIter iter;
        int count = 0;
+       BMElemF *ele_f;
+       int i;
 
-       if (htype & BM_VERT) {
-               for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                       if (BMO_TestFlag(bm, e, flag))
-                               count++;
-               }
-       }
-       if (htype & BM_EDGE) {
-               for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                       if (BMO_TestFlag(bm, e, flag))
-                               count++;
-               }
-       }
-       if (htype & BM_FACE) {
-               for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                       if (BMO_TestFlag(bm, e, flag))
-                               count++;
+       BLI_assert(ELEM(TRUE, FALSE, test_for_enabled));
+
+       for (i = 0; i < 3; i++) {
+               if (htype & flag_types[i]) {
+                       BM_ITER_MESH (ele_f, &iter, bm, iter_types[i]) {
+                               if (BMO_elem_flag_test_bool(bm, ele_f, oflag) == test_for_enabled)
+                                       count++;
+                       }
                }
        }
 
-       return count;   
+       return count;
 }
 
-void BMO_Clear_Flag_All(BMesh *bm, BMOperator *UNUSED(op), const char htype, int flag)
+
+int BMO_mesh_enabled_flag_count(BMesh *bm, const char htype, const short oflag)
 {
+       return bmo_mesh_flag_count(bm, htype, oflag, TRUE);
+}
+
+int BMO_mesh_disabled_flag_count(BMesh *bm, const char htype, const short oflag)
+{
+       return bmo_mesh_flag_count(bm, htype, oflag, FALSE);
+}
+
+void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *UNUSED(op), const char htype, const short oflag)
+{
+       const char iter_types[3] = {BM_VERTS_OF_MESH,
+                                   BM_EDGES_OF_MESH,
+                                   BM_FACES_OF_MESH};
+
+       const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE};
+
        BMIter iter;
-       BMHeader *ele;
-       int types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH};
-       int flags[3] = {BM_VERT, BM_EDGE, BM_FACE};
+       BMElemF *ele;
        int i;
 
        for (i = 0; i < 3; i++) {
-               if (htype & flags[i]) {
-                       BM_ITER(ele, &iter, bm, types[i], NULL) {
-                               BMO_ClearFlag(bm, ele, flag);
+               if (htype & flag_types[i]) {
+                       BM_ITER_MESH (ele, &iter, bm, iter_types[i]) {
+                               BMO_elem_flag_disable(bm, ele, oflag);
                        }
                }
        }
 }
 
-int BMO_CountSlotBuf(struct BMesh *UNUSED(bm), struct BMOperator *op, const char *slotname)
+int BMO_slot_buffer_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
        
        /* check if its actually a buffer */
-       if (!(slot->slottype > BMOP_OPSLOT_VEC))
+       if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
                return 0;
 
        return slot->len;
 }
 
-int BMO_CountSlotMap(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
+int BMO_slot_map_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING);
        
        /* check if its actually a buffer */
-       if (!(slot->slottype == BMOP_OPSLOT_MAPPING))
+       if (!(slot->slottype == BMO_OP_SLOT_MAPPING))
                return 0;
 
        return slot->data.ghash ? BLI_ghash_size(slot->data.ghash) : 0;
 }
 
+/* inserts a key/value mapping into a mapping slot.  note that it copies the
+ * value, it doesn't store a reference to it. */
+
+void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname,
+                         void *element, void *data, int len)
+{
+       BMOElemMapping *mapping;
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING);
+
+       mapping = (BMOElemMapping *) BLI_memarena_alloc(op->arena, sizeof(*mapping) + len);
+
+       mapping->element = (BMHeader *) element;
+       mapping->len = len;
+       memcpy(mapping + 1, data, len);
+
+       if (!slot->data.ghash) {
+               slot->data.ghash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh slot map hash");
+       }
+
+       BLI_ghash_insert(slot->data.ghash, element, mapping);
+}
+
 #if 0
-void *BMO_Grow_Array(BMesh *bm, BMOperator *op, int slotcode, int totadd)
+void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd)
 {
        BMOpSlot *slot = &op->slots[slotcode];
        void *tmp;
+       ssize_t allocsize;
        
+       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+
        /* check if its actually a buffer */
-       if (!(slot->slottype > BMOP_OPSLOT_VEC))
+       if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
                return NULL;
 
        if (slot->flag & BMOS_DYNAMIC_ARRAY) {
                if (slot->len >= slot->size) {
                        slot->size = (slot->size + 1 + totadd) * 2;
 
+                       allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->size;
+
                        tmp = slot->data.buf;
-                       slot->data.buf = MEM_callocN(BMOP_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->size, "opslot dynamic array");
-                       memcpy(slot->data.buf, tmp, BMOP_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->size);
+                       slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array");
+                       memcpy(slot->data.buf, tmp, allocsize);
                        MEM_freeN(tmp);
                }
 
@@ -529,58 +593,61 @@ void *BMO_Grow_Array(BMesh *bm, BMOperator *op, int slotcode, int totadd)
                slot->flag |= BMOS_DYNAMIC_ARRAY;
                slot->len += totadd;
                slot->size = slot->len + 2;
+
+               allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->len;
+
                tmp = slot->data.buf;
-               slot->data.buf = MEM_callocN(BMOP_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->len, "opslot dynamic array");
-               memcpy(slot->data.buf, tmp, BMOP_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->len);
+               slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array");
+               memcpy(slot->data.buf, tmp, allocsize);
        }
 
        return slot->data.buf;
 }
 #endif
 
-void BMO_Mapping_To_Flag(struct BMesh *bm, struct BMOperator *op, 
-                        const char *slotname, int flag)
+void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
+                          const char htype, const short oflag)
 {
        GHashIterator it;
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       BMHeader *ele;
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMElemF *ele_f;
+
+       BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING);
 
        /* sanity check */
-       if (slot->slottype != BMOP_OPSLOT_MAPPING) return;
        if (!slot->data.ghash) return;
 
        BLI_ghashIterator_init(&it, slot->data.ghash);
-       for ( ; (ele = BLI_ghashIterator_getKey(&it)); BLI_ghashIterator_step(&it)) {
-               BMO_SetFlag(bm, ele, flag);
+       for ( ; (ele_f = BLI_ghashIterator_getKey(&it)); BLI_ghashIterator_step(&it)) {
+               if (ele_f->head.htype & htype) {
+                       BMO_elem_flag_enable(bm, ele_f, oflag);
+               }
        }
 }
 
-static void *alloc_slot_buffer(BMOperator *op, const char *slotname, int len)
+static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slotname, int len)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
 
        /* check if its actually a buffer */
-       if (!(slot->slottype > BMOP_OPSLOT_VEC))
+       if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
                return NULL;
        
        slot->len = len;
        if (len)
-               slot->data.buf = BLI_memarena_alloc(op->arena, BMOP_OPSLOT_TYPEINFO[slot->slottype] * len);
+               slot->data.buf = BLI_memarena_alloc(op->arena, BMO_OPSLOT_TYPEINFO[slot->slottype] * len);
        return slot->data.buf;
 }
 
-/*
- * BMO_ALL_TO_SLOT
+/**
+ * \brief BMO_ALL_TO_SLOT
  *
  * Copies all elements of a certain type into an operator slot.
- *
  */
-
-static void BMO_All_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, const char htype)
+static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slotname, const char htype)
 {
-       BMIter elements;
-       BMHeader *e;
-       BMOpSlot *output = BMO_GetSlot(op, slotname);
+       BMOpSlot *output = BMO_slot_get(op, slotname);
        int totelement = 0, i = 0;
        
        if (htype & BM_VERT) totelement += bm->totvert;
@@ -588,73 +655,92 @@ static void BMO_All_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, con
        if (htype & BM_FACE) totelement += bm->totface;
 
        if (totelement) {
-               alloc_slot_buffer(op, slotname, totelement);
+               BMIter iter;
+               BMHeader *ele;
+
+               bmo_slot_buffer_alloc(op, slotname, totelement);
+
+               /* TODO - collapse these loops into one */
 
                if (htype & BM_VERT) {
-                       for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
+                               ((BMHeader **)output->data.p)[i] = ele;
                                i++;
                        }
                }
 
                if (htype & BM_EDGE) {
-                       for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
+                               ((BMHeader **)output->data.p)[i] = ele;
                                i++;
                        }
                }
 
                if (htype & BM_FACE) {
-                       for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
+                               ((BMHeader **)output->data.p)[i] = ele;
                                i++;
                        }
                }
        }
 }
 
-/*
- * BMO_HEADERFLAG_TO_SLOT
+/**
+ * \brief BMO_HEADERFLAG_TO_SLOT
  *
- * Copies elements of a certain type, which have a certain header flag set 
- * into a slot for an operator.
+ * Copies elements of a certain type, which have a certain header flag
+ * enabled/disabled into a slot for an operator.
  */
-
-void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
-                            const char hflag, const char htype)
+static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *slotname,
+                                       const char htype, const char hflag,
+                                       const short test_for_enabled)
 {
-       BMIter elements;
-       BMHeader *e;
-       BMOpSlot *output = BMO_GetSlot(op, slotname);
+       BMOpSlot *output = BMO_slot_get(op, slotname);
        int totelement = 0, i = 0;
-       
-       totelement = BM_CountFlag(bm, htype, hflag, 1);
+
+       BLI_assert(ELEM(TRUE, FALSE, test_for_enabled));
+
+       if (test_for_enabled)
+               totelement = BM_mesh_elem_hflag_count_enabled(bm, htype, hflag, TRUE);
+       else
+               totelement = BM_mesh_elem_hflag_count_disabled(bm, htype, hflag, TRUE);
 
        if (totelement) {
-               alloc_slot_buffer(op, slotname, totelement);
+               BMIter iter;
+               BMElem *ele;
+
+               bmo_slot_buffer_alloc(op, slotname, totelement);
+
+               /* TODO - collapse these loops into one */
 
                if (htype & BM_VERT) {
-                       for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               if (!BM_TestHFlag(e, BM_HIDDEN) && BM_TestHFlag(e, hflag)) {
-                                       ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
+                               if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
+                                   BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
+                               {
+                                       ((BMElem **)output->data.p)[i] = ele;
                                        i++;
                                }
                        }
                }
 
                if (htype & BM_EDGE) {
-                       for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               if (!BM_TestHFlag(e, BM_HIDDEN) && BM_TestHFlag(e, hflag)) {
-                                       ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
+                               if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
+                                   BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
+                               {
+                                       ((BMElem **)output->data.p)[i] = ele;
                                        i++;
                                }
                        }
                }
 
                if (htype & BM_FACE) {
-                       for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               if (!BM_TestHFlag(e, BM_HIDDEN) && BM_TestHFlag(e, hflag)) {
-                                       ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
+                               if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
+                                   BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
+                               {
+                                       ((BMElem **)output->data.p)[i] = ele;
                                        i++;
                                }
                        }
@@ -665,107 +751,193 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
        }
 }
 
-/*
- *
- * BMO_FLAG_TO_SLOT
+void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, const char *slotname,
+                                        const char htype, const char hflag)
+{
+       bmo_slot_buffer_from_hflag(bm, op, slotname, htype, hflag, TRUE);
+}
+
+void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, const char *slotname,
+                                         const char htype, const char hflag)
+{
+       bmo_slot_buffer_from_hflag(bm, op, slotname, htype, hflag, FALSE);
+}
+
+/**
+ * Copies the values from another slot to the end of the output slot.
+ */
+void BMO_slot_buffer_append(BMOperator *output_op, const char *output_slot_name,
+                            BMOperator *other_op, const char *other_slot_name)
+{
+       BMOpSlot *output_slot = BMO_slot_get(output_op, output_slot_name);
+       BMOpSlot *other_slot = BMO_slot_get(other_op, other_slot_name);
+
+       BLI_assert(output_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF &&
+                  other_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+
+       if (output_slot->len == 0) {
+               /* output slot is empty, copy rather than append */
+               BMO_slot_copy(other_op, output_op, other_slot_name, output_slot_name);
+       }
+       else if (other_slot->len != 0) {
+               int elem_size = BMO_OPSLOT_TYPEINFO[output_slot->slottype];
+               int alloc_size = elem_size * (output_slot->len + other_slot->len);
+               /* allocate new buffer */
+               void *buf = BLI_memarena_alloc(output_op->arena, alloc_size);
+
+               /* copy slot data */
+               memcpy(buf, output_slot->data.buf, elem_size * output_slot->len);
+               memcpy(((char *)buf) + elem_size * output_slot->len, other_slot->data.buf, elem_size * other_slot->len);
+
+               output_slot->data.buf = buf;
+               output_slot->len += other_slot->len;
+       }
+}
+
+/**
+ * \brief BMO_FLAG_TO_SLOT
  *
- * Copies elements of a certain type, which have a certain flag set 
+ * Copies elements of a certain type, which have a certain flag set
  * into an output slot for an operator.
  */
-void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
-                      const int flag, const char htype)
+static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slotname,
+                                      const char htype, const short oflag,
+                                      const short test_for_enabled)
 {
-       BMIter elements;
-       BMHeader *e;
-       BMOpSlot *output = BMO_GetSlot(op, slotname);
-       int totelement = BMO_CountFlag(bm, flag, htype), i = 0;
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       int totelement, i = 0;
+
+       BLI_assert(ELEM(TRUE, FALSE, test_for_enabled));
+
+       if (test_for_enabled)
+               totelement = BMO_mesh_enabled_flag_count(bm, htype, oflag);
+       else
+               totelement = BMO_mesh_disabled_flag_count(bm, htype, oflag);
+
+       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
 
        if (totelement) {
-               alloc_slot_buffer(op, slotname, totelement);
+               BMIter iter;
+               BMHeader *ele;
+               BMHeader **ele_array;
+
+               bmo_slot_buffer_alloc(op, slotname, totelement);
+
+               ele_array = (BMHeader **)slot->data.p;
+
+               /* TODO - collapse these loops into one */
 
                if (htype & BM_VERT) {
-                       for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               if (BMO_TestFlag(bm, e, flag)) {
-                                       ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
+                               if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
+                                       ele_array[i] = ele;
                                        i++;
                                }
                        }
                }
 
                if (htype & BM_EDGE) {
-                       for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               if (BMO_TestFlag(bm, e, flag)) {
-                                       ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
+                               if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
+                                       ele_array[i] = ele;
                                        i++;
                                }
                        }
                }
 
                if (htype & BM_FACE) {
-                       for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
-                               if (BMO_TestFlag(bm, e, flag)) {
-                                       ((BMHeader **)output->data.p)[i] = e;
+                       BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
+                               if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
+                                       ele_array[i] = ele;
                                        i++;
                                }
                        }
                }
        }
        else {
-               output->len = 0;
+               slot->len = 0;
        }
 }
 
-/*
- *
- * BMO_FLAG_BUFFER
+void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
+                                       const char htype, const short oflag)
+{
+       bmo_slot_buffer_from_flag(bm, op, slotname, htype, oflag, TRUE);
+}
+
+void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slotname,
+                                        const char htype, const short oflag)
+{
+       bmo_slot_buffer_from_flag(bm, op, slotname, htype, oflag, FALSE);
+}
+
+/**
+ * \brief BMO_FLAG_BUFFER
  *
  * Header Flags elements in a slots buffer, automatically
  * using the selection API where appropriate.
  */
-void BMO_HeaderFlag_Buffer(BMesh *bm, BMOperator *op, const char *slotname,
-                           const char hflag, const char htype)
+void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slotname,
+                                  const char htype, const char hflag, const char do_flush)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       BMHeader **data =  slot->data.p;
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMElem **data =  slot->data.p;
        int i;
-       
-       for (i = 0; i < slot->len; i++) {
-               if (!(htype & data[i]->htype))
+       const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT));
+       const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN));
+
+       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+
+       for (i = 0; i < slot->len; i++, data++) {
+               if (!(htype & (*data)->head.htype))
                        continue;
 
-               if (hflag & BM_SELECT) {
-                       BM_Select(bm, data[i], TRUE);
+               if (do_flush_select) {
+                       BM_elem_select_set(bm, *data, TRUE);
+               }
+
+               if (do_flush_hide) {
+                       BM_elem_hide_set(bm, *data, FALSE);
                }
-               BM_SetHFlag(data[i], hflag);
+
+               BM_elem_flag_enable(*data, hflag);
        }
 }
 
-/*
- *
- * BMO_FLAG_BUFFER
+/**
+ * \brief BMO_FLAG_BUFFER
  *
  * Removes flags from elements in a slots buffer, automatically
  * using the selection API where appropriate.
  */
-void BMO_UnHeaderFlag_Buffer(BMesh *bm, BMOperator *op, const char *slotname,
-                             const char hflag, const char htype)
+void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slotname,
+                                   const char htype, const char hflag, const char do_flush)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
-       BMHeader **data =  slot->data.p;
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
+       BMElem **data =  slot->data.p;
        int i;
-       
-       for (i = 0; i < slot->len; i++) {
-               if (!(htype & data[i]->htype))
+       const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT));
+       const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN));
+
+       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+
+       for (i = 0; i < slot->len; i++, data++) {
+               if (!(htype & (*data)->head.htype))
                        continue;
 
-               if (hflag & BM_SELECT) {
-                       BM_Select(bm, data[i], FALSE);
+               if (do_flush_select) {
+                       BM_elem_select_set(bm, *data, FALSE);
+               }
+
+               if (do_flush_hide) {
+                       BM_elem_hide_set(bm, *data, FALSE);
                }
 
-               BM_ClearHFlag(data[i], hflag);
+               BM_elem_flag_disable(*data, hflag);
        }
 }
-int BMO_Vert_CountEdgeFlags(BMesh *bm, BMVert *v, int toolflag)
+
+int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag)
 {
        int count = 0;
 
@@ -775,75 +947,76 @@ int BMO_Vert_CountEdgeFlags(BMesh *bm, BMVert *v, int toolflag)
                int i;
                
                for (i = 0, curedge = v->e; i < len; i++) {
-                       if (BMO_TestFlag(bm, curedge, toolflag))
+                       if (BMO_elem_flag_test(bm, curedge, oflag))
                                count++;
-                       curedge = bmesh_disk_nextedge(curedge, v);
+                       curedge = bmesh_disk_edge_next(curedge, v);
                }
        }
 
        return count;
 }
 
-/*
- *
- * BMO_FLAG_BUFFER
+/**
+ * \brief BMO_FLAG_BUFFER
  *
  * Flags elements in a slots buffer
  */
-void BMO_Flag_Buffer(BMesh *bm, BMOperator *op, const char *slotname,
-                     const int hflag, const char htype)
+void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slotname,
+                                 const char htype, const short oflag)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
        BMHeader **data =  slot->data.p;
        int i;
-       
+
+       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+
        for (i = 0; i < slot->len; i++) {
                if (!(htype & data[i]->htype))
                        continue;
 
-               BMO_SetFlag(bm, data[i], hflag);
+               BMO_elem_flag_enable(bm, (BMElemF *)data[i], oflag);
        }
 }
 
-/*
- *
- * BMO_FLAG_BUFFER
+/**
+ * \brief BMO_FLAG_BUFFER
  *
  * Removes flags from elements in a slots buffer
  */
-void BMO_Unflag_Buffer(BMesh *bm, BMOperator *op, const char *slotname,
-                       const int flag, const char htype)
+void BMO_slot_buffer_flag_disable(BMesh *bm, BMOperator *op, const char *slotname,
+                                  const char htype, const short oflag)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
        BMHeader **data =  slot->data.p;
        int i;
-       
+
+       BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
+
        for (i = 0; i < slot->len; i++) {
                if (!(htype & data[i]->htype))
                        continue;
 
-               BMO_ClearFlag(bm, data[i], flag);
+               BMO_elem_flag_disable(bm, (BMElemF *)data[i], oflag);
        }
 }
 
 
-/*
+/**
+ * \brief ALLOC/FREE FLAG LAYER
  *
- *     ALLOC/FREE FLAG LAYER
+ * Used by operator stack to free/allocate
+ * private flag data. This is allocated
+ * using a mempool so the allocation/frees
+ * should be quite fast.
  *
- *  Used by operator stack to free/allocate 
- *  private flag data. This is allocated
- *  using a mempool so the allocation/frees
- *  should be quite fast.
- *
- *  BMESH_TODO:
- *     Investigate not freeing flag layers until
- *  all operators have been executed. This would
- *  save a lot of realloc potentially.
+ * BMESH_TODO:
+ * Investigate not freeing flag layers until
+ * all operators have been executed. This would
+ * save a lot of realloc potentially.
  */
-static void alloc_flag_layer(BMesh *bm)
+static void bmo_flag_layer_alloc(BMesh *bm)
 {
-       BMHeader *ele;
+       BMElemF *ele;
        /* set the index values since we are looping over all data anyway,
         * may save time later on */
        int i;
@@ -859,26 +1032,26 @@ static void alloc_flag_layer(BMesh *bm)
        bm->totflags++;
 
        /* allocate new flag poo */
-       bm->toolflagpool = newpool = BLI_mempool_create(sizeof(BMFlagLayer)*bm->totflags, 512, 512, FALSE, FALSE);
+       bm->toolflagpool = newpool = BLI_mempool_create(sizeof(BMFlagLayer) * bm->totflags, 512, 512, 0);
        
        /* now go through and memcpy all the flags. Loops don't get a flag layer at this time.. */
-       for (ele = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) {
-               oldflags = ele->flags;
-               ele->flags = BLI_mempool_calloc(newpool);
-               memcpy(ele->flags, oldflags, old_totflags_size);
-               BM_SetIndex(ele, i); /* set_inline */
+       BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
+               oldflags = ele->oflags;
+               ele->oflags = BLI_mempool_calloc(newpool);
+               memcpy(ele->oflags, oldflags, old_totflags_size);
+               BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) {
-               oldflags = ele->flags;
-               ele->flags = BLI_mempool_calloc(newpool);
-               memcpy(ele->flags, oldflags, old_totflags_size);
-               BM_SetIndex(ele, i); /* set_inline */
+       BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
+               oldflags = ele->oflags;
+               ele->oflags = BLI_mempool_calloc(newpool);
+               memcpy(ele->oflags, oldflags, old_totflags_size);
+               BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BMIter_New(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) {
-               oldflags = ele->flags;
-               ele->flags = BLI_mempool_calloc(newpool);
-               memcpy(ele->flags, oldflags, old_totflags_size);
-               BM_SetIndex(ele, i); /* set_inline */
+       BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
+               oldflags = ele->oflags;
+               ele->oflags = BLI_mempool_calloc(newpool);
+               memcpy(ele->oflags, oldflags, old_totflags_size);
+               BM_elem_index_set(ele, i); /* set_inline */
        }
 
        bm->elem_index_dirty &= ~(BM_VERT|BM_EDGE|BM_FACE);
@@ -886,9 +1059,9 @@ static void alloc_flag_layer(BMesh *bm)
        BLI_mempool_destroy(oldpool);
 }
 
-static void free_flag_layer(BMesh *bm)
+static void bmo_flag_layer_free(BMesh *bm)
 {
-       BMHeader *ele;
+       BMElemF *ele;
        /* set the index values since we are looping over all data anyway,
         * may save time later on */
        int i;
@@ -904,26 +1077,26 @@ static void free_flag_layer(BMesh *bm)
        /* de-increment the totflags first.. */
        bm->totflags--;
        /* allocate new flag poo */
-       bm->toolflagpool = newpool = BLI_mempool_create(new_totflags_size, 512, 512, TRUE, FALSE);
+       bm->toolflagpool = newpool = BLI_mempool_create(new_totflags_size, 512, 512, BLI_MEMPOOL_SYSMALLOC);
        
        /* now go through and memcpy all the flag */
-       for (ele = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) {
-               oldflags = ele->flags;
-               ele->flags = BLI_mempool_calloc(newpool);
-               memcpy(ele->flags, oldflags, new_totflags_size);
-               BM_SetIndex(ele, i); /* set_inline */
+       BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
+               oldflags = ele->oflags;
+               ele->oflags = BLI_mempool_calloc(newpool);
+               memcpy(ele->oflags, oldflags, new_totflags_size);
+               BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) {
-               oldflags = ele->flags;
-               ele->flags = BLI_mempool_calloc(newpool);
-               memcpy(ele->flags, oldflags, new_totflags_size);
-               BM_SetIndex(ele, i); /* set_inline */
+       BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
+               oldflags = ele->oflags;
+               ele->oflags = BLI_mempool_calloc(newpool);
+               memcpy(ele->oflags, oldflags, new_totflags_size);
+               BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (ele = BMIter_New(&iter, bm, BM_FACES_OF_MESH, bm), i = 0; ele; ele = BMIter_Step(&iter), i++) {
-               oldflags = ele->flags;
-               ele->flags = BLI_mempool_calloc(newpool);
-               memcpy(ele->flags, oldflags, new_totflags_size);
-               BM_SetIndex(ele, i); /* set_inline */
+       BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
+               oldflags = ele->oflags;
+               ele->oflags = BLI_mempool_calloc(newpool);
+               memcpy(ele->oflags, oldflags, new_totflags_size);
+               BM_elem_index_set(ele, i); /* set_inline */
        }
 
        bm->elem_index_dirty &= ~(BM_VERT|BM_EDGE|BM_FACE);
@@ -931,42 +1104,53 @@ static void free_flag_layer(BMesh *bm)
        BLI_mempool_destroy(oldpool);
 }
 
-static void clear_flag_layer(BMesh *bm)
+static void bmo_flag_layer_clear(BMesh *bm)
 {
-       BMVert *v;
-       BMEdge *e;
-       BMFace *f;
-       
-       BMIter verts;
-       BMIter edges;
-       BMIter faces;
-       
+       BMElemF *ele;
+       /* set the index values since we are looping over all data anyway,
+        * may save time later on */
+       int i;
+
+       BMIter iter;
+       const int totflags_offset = bm->totflags - 1;
+
        /* now go through and memcpy all the flag */
-       for (v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) {
-               memset(v->head.flags + (bm->totflags - 1), 0, sizeof(BMFlagLayer));
+       BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
+               memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
+               BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) {
-               memset(e->head.flags + (bm->totflags - 1), 0, sizeof(BMFlagLayer));
+       BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
+               memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
+               BM_elem_index_set(ele, i); /* set_inline */
        }
-       for (f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) {
-               memset(f->head.flags + (bm->totflags - 1), 0, sizeof(BMFlagLayer));
+       BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
+               memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
+               BM_elem_index_set(ele, i); /* set_inline */
        }
+
+       bm->elem_index_dirty &= ~(BM_VERT|BM_EDGE|BM_FACE);
 }
 
-void *BMO_FirstElem(BMOperator *op, const char *slotname)
+void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slotname)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
        
-       if (slot->slottype != BMOP_OPSLOT_ELEMENT_BUF)
+       if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF)
                return NULL;
 
        return slot->data.buf ? *(void **)slot->data.buf : NULL;
 }
 
-void *BMO_IterNew(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
-                 const char *slotname, const char restrictmask)
+/**
+ * \brief New Iterator
+ *
+ * \param restrictmask restricts the iteration to certain element types
+ * (e.g. combination of BM_VERT, BM_EDGE, BM_FACE), if iterating
+ * over an element buffer (not a mapping). */
+void *BMO_iter_new(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
+                   const char *slotname, const char restrictmask)
 {
-       BMOpSlot *slot = BMO_GetSlot(op, slotname);
+       BMOpSlot *slot = BMO_slot_get(op, slotname);
 
        memset(iter, 0, sizeof(BMOIter));
 
@@ -974,7 +1158,7 @@ void *BMO_IterNew(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
        iter->cur = 0;
        iter->restrictmask = restrictmask;
 
-       if (iter->slot->slottype == BMOP_OPSLOT_MAPPING) {
+       if (iter->slot->slottype == BMO_OP_SLOT_MAPPING) {
                if (iter->slot->data.ghash) {
                        BLI_ghashIterator_init(&iter->giter, slot->data.ghash);
                }
@@ -983,12 +1167,12 @@ void *BMO_IterNew(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
                }
        }
 
-       return BMO_IterStep(iter);
+       return BMO_iter_step(iter);
 }
 
-void *BMO_IterStep(BMOIter *iter)
+void *BMO_iter_step(BMOIter *iter)
 {
-       if (iter->slot->slottype == BMOP_OPSLOT_ELEMENT_BUF) {
+       if (iter->slot->slottype == BMO_OP_SLOT_ELEMENT_BUF) {
                BMHeader *h;
 
                if (iter->cur >= iter->slot->len) {
@@ -1006,8 +1190,8 @@ void *BMO_IterStep(BMOIter *iter)
 
                return h;
        }
-       else if (iter->slot->slottype == BMOP_OPSLOT_MAPPING) {
-               struct element_mapping *map; 
+       else if (iter->slot->slottype == BMO_OP_SLOT_MAPPING) {
+               BMOElemMapping *map;
                void *ret = BLI_ghashIterator_getKey(&iter->giter);
                map = BLI_ghashIterator_getValue(&iter->giter);
                
@@ -1022,55 +1206,55 @@ void *BMO_IterStep(BMOIter *iter)
 }
 
 /* used for iterating over mapping */
-void *BMO_IterMapVal(BMOIter *iter)
+void *BMO_iter_map_value(BMOIter *iter)
 {
        return iter->val;
 }
 
-void *BMO_IterMapValp(BMOIter *iter)
+void *BMO_iter_map_value_p(BMOIter *iter)
 {
        return *((void **)iter->val);
 }
 
-float BMO_IterMapValf(BMOIter *iter)
+float BMO_iter_map_value_f(BMOIter *iter)
 {
        return *((float *)iter->val);
 }
 
 /* error syste */
-typedef struct bmop_error {
-       struct bmop_error *next, *prev;
-       int errorcode;
-       BMOperator *op;
-       const char *msg;
-} bmop_error;
-
-void BMO_ClearStack(BMesh *bm)
+typedef struct BMOpError {
+       struct BMOpError *next, *prev;
+       int errorcode;
+       BMOperator *op;
+       const char *msg;
+} BMOpError;
+
+void BMO_error_clear(BMesh *bm)
 {
-       while (BMO_PopError(bm, NULL, NULL));
+       while (BMO_error_pop(bm, NULL, NULL));
 }
 
-void BMO_RaiseError(BMesh *bm, BMOperator *owner, int errcode, const char *msg)
+void BMO_error_raise(BMesh *bm, BMOperator *owner, int errcode, const char *msg)
 {
-       bmop_error *err = MEM_callocN(sizeof(bmop_error), "bmop_error");
+       BMOpError *err = MEM_callocN(sizeof(BMOpError), "bmop_error");
        
        err->errorcode = errcode;
-       if (!msg) msg = bmop_error_messages[errcode];
+       if (!msg) msg = bmo_error_messages[errcode];
        err->msg = msg;
        err->op = owner;
        
        BLI_addhead(&bm->errorstack, err);
 }
 
-int BMO_HasError(BMesh *bm)
+int BMO_error_occurred(BMesh *bm)
 {
        return bm->errorstack.first != NULL;
 }
 
 /* returns error code or 0 if no erro */
-int BMO_GetError(BMesh *bm, const char **msg, BMOperator **op)
+int BMO_error_get(BMesh *bm, const char **msg, BMOperator **op)
 {
-       bmop_error *err = bm->errorstack.first;
+       BMOpError *err = bm->errorstack.first;
        if (!err) {
                return 0;
        }
@@ -1081,12 +1265,12 @@ int BMO_GetError(BMesh *bm, const char **msg, BMOperator **op)
        return err->errorcode;
 }
 
-int BMO_PopError(BMesh *bm, const char **msg, BMOperator **op)
+int BMO_error_pop(BMesh *bm, const char **msg, BMOperator **op)
 {
-       int errorcode = BMO_GetError(bm, msg, op);
+       int errorcode = BMO_error_get(bm, msg, op);
        
        if (errorcode) {
-               bmop_error *err = bm->errorstack.first;
+               BMOpError *err = bm->errorstack.first;
                
                BLI_remlink(&bm->errorstack, bm->errorstack.first);
                MEM_freeN(err);
@@ -1095,53 +1279,10 @@ int BMO_PopError(BMesh *bm, const char **msg, BMOperator **op)
        return errorcode;
 }
 
-#if 0
-typedef struct bflag {
-       const char *str;
-       int flag;
-} bflag;
-
-#define b(f) {#f, f},
-static const char *bmesh_flags = {
-       b(BM_SELECT);
-       b(BM_SEAM);
-       b(BM_FGON);
-       b(BM_HIDDEN);
-       b(BM_SHARP);
-       b(BM_SMOOTH);
-       {NULL, 0};
-};
-
-int bmesh_str_to_flag(const char *str)
-{
-       int i;
 
-       while (bmesh_flags[i]->name) {
-               if (!strcmp(bmesh_flags[i]->name, str))
-                       return bmesh_flags[i]->flag;
-       }
+#define NEXT_CHAR(fmt) ((fmt)[0] != 0 ? (fmt)[1] : 0)
 
-       return -1;
-}
-#endif
-
-/* example:
- * BMO_CallOp(bm, "del %d %hv", DEL_ONLYFACES, BM_SELECT);
- *
- *  d - int
- *  i - int
- *  f - float
- *  hv - header flagged verts
- *  he - header flagged edges
- *  hf - header flagged faces
- *  fv - flagged verts
- *  fe - flagged edges
- *  ff - flagged faces
- */
-
-#define nextc(fmt) ((fmt)[0] != 0 ? (fmt)[1] : 0)
-
-static int bmesh_name_to_slotcode(BMOpDefine *def, const char *name)
+static int bmo_name_to_slotcode(BMOpDefine *def, const char *name)
 {
        int i;
 
@@ -1154,9 +1295,9 @@ static int bmesh_name_to_slotcode(BMOpDefine *def, const char *name)
        return -1;
 }
 
-static int bmesh_name_to_slotcode_check(BMOpDefine *def, const char *name)
+static int bmo_name_to_slotcode_check(BMOpDefine *def, const char *name)
 {
-       int i = bmesh_name_to_slotcode(def, name);
+       int i = bmo_name_to_slotcode(def, name);
        if (i < 0) {
                fprintf(stderr, "%s: ! could not find bmesh slot for name %s! (bmesh internal error)\n", __func__, name);
        }
@@ -1164,7 +1305,7 @@ static int bmesh_name_to_slotcode_check(BMOpDefine *def, const char *name)
        return i;
 }
 
-static int bmesh_opname_to_opcode(const char *opname)
+static int bmo_opname_to_opcode(const char *opname)
 {
        int i;
 
@@ -1178,25 +1319,46 @@ static int bmesh_opname_to_opcode(const char *opname)
        return -1;
 }
 
-int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
+/* Example:
+ * BMO_op_callf(bm, "del %i %hv", DEL_ONLYFACES, BM_ELEM_SELECT);
+ *
+ *  i - int
+ *  b - boolean (same as int but 1/0 only)
+ *  f - float
+ *  hv - header flagged verts (hflag)
+ *  he - header flagged edges (hflag)
+ *  hf - header flagged faces (hflag)
+ *  fv - flagged verts (oflag)
+ *  fe - flagged edges (oflag)
+ *  ff - flagged faces (oflag)
+ */
+
+int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
 {
        BMOpDefine *def;
        char *opname, *ofmt, *fmt;
        char slotname[64] = {0};
-       int i /*, n = strlen(fmt) */, stop /*, slotcode = -1 */, ret, type, state;
+       int i /*, n = strlen(fmt) */, stop /*, slotcode = -1 */, type, state;
+       char htype;
        int noslot = 0;
 
 
        /* basic useful info to help find where bmop formatting strings fail */
+       const char *err_reason = "Unknown";
        int lineno = -1;
-#   define GOTO_ERROR { lineno = __LINE__; goto error; }
 
+#define GOTO_ERROR(reason)   \
+       {                        \
+               err_reason = reason; \
+               lineno = __LINE__;   \
+               goto error;          \
+       } (void)0
 
        /* we muck around in here, so dup i */
        fmt = ofmt = BLI_strdup(_fmt);
        
-       /* find operator nam */
-       i = strcspn(fmt, " \t");
+       /* find operator name */
+       i = strcspn(fmt, " ");
 
        opname = fmt;
        if (!opname[i]) noslot = 1;
@@ -1204,38 +1366,40 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
 
        fmt += i + (noslot ? 0 : 1);
        
-       i = bmesh_opname_to_opcode(opname);
+       i = bmo_opname_to_opcode(opname);
 
        if (i == -1) {
                MEM_freeN(ofmt);
-               return 0;
+               return FALSE;
        }
 
-       BMO_Init_Op(bm, op, opname);
+       BMO_op_init(bm, op, opname);
        def = opdefines[i];
        
        i = 0;
-       state = 1; //0: not inside slotcode name, 1: inside slotcode name
+       state = 1; /* 0: not inside slotcode name, 1: inside slotcode name */
 
        while (*fmt) {
                if (state) {
                        /* jump past leading whitespac */
-                       i = strspn(fmt, " \t");
+                       i = strspn(fmt, " ");
                        fmt += i;
                        
                        /* ignore trailing whitespac */
                        if (!fmt[i])
                                break;
 
-                       /* find end of slot name.  currently this is
-                        * a little flexible, allowing "slot=%f",
-                        * "slot %f", "slot%f", and "slot\t%f". */
-                       i = strcspn(fmt, "= \t%");
-                       if (!fmt[i]) GOTO_ERROR;
+                       /* find end of slot name, only "slot=%f", can be used */
+                       i = strcspn(fmt, "=");
+                       if (!fmt[i]) {
+                               GOTO_ERROR("could not match end of slot name");
+                       }
 
                        fmt[i] = 0;
 
-                       if (bmesh_name_to_slotcode_check(def, fmt) < 0) GOTO_ERROR;
+                       if (bmo_name_to_slotcode_check(def, fmt) < 0) {
+                               GOTO_ERROR("name to slot code check failed");
+                       }
                        
                        BLI_strncpy(slotname, fmt, sizeof(slotname));
                        
@@ -1244,211 +1408,181 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
                }
                else {
                        switch (*fmt) {
-                       case ' ':
-                       case '\t':
-                       case '=':
-                       case '%':
-                               break;
-                       case 'm': {
-                               int size, c;
-                               
-                               c = nextc(fmt);
-                               fmt++;
-
-                               if (c == '3') size = 3;
-                               else if (c == '4') size = 4;
-                               else GOTO_ERROR;
-
-                               BMO_Set_Mat(op, slotname, va_arg(vlist, void *), size);
-                               state = 1;
-                               break;
-                       }
-                       case 'v': {
-                               BMO_Set_Vec(op, slotname, va_arg(vlist, float *));
-                               state = 1;
-                               break;
-                       }
-                       case 'e': {
-                               BMHeader *ele = va_arg(vlist, void *);
-                               BMOpSlot *slot = BMO_GetSlot(op, slotname);
+                               case ' ':
+                               case '=':
+                               case '%':
+                                       break;
+                               case 'm': {
+                                       int size, c;
+
+                                       c = NEXT_CHAR(fmt);
+                                       fmt++;
 
-                               slot->data.buf = BLI_memarena_alloc(op->arena, sizeof(void *) * 4);
-                               slot->len = 1;
-                               *((void **)slot->data.buf) = ele;
+                                       if      (c == '3') size = 3;
+                                       else if (c == '4') size = 4;
+                                       else GOTO_ERROR("matrix size was not 3 or 4");
 
-                               state = 1;
-                               break;
-                       }
-                       case 's': {
-                               BMOperator *op2 = va_arg(vlist, void *);
-                               const char *slotname2 = va_arg(vlist, char *);
+                                       BMO_slot_mat_set(op, slotname, va_arg(vlist, void *), size);
+                                       state = 1;
+                                       break;
+                               }
+                               case 'v': {
+                                       BMO_slot_vec_set(op, slotname, va_arg(vlist, float *));
+                                       state = 1;
+                                       break;
+                               }
+                               case 'e': {
+                                       BMHeader *ele = va_arg(vlist, void *);
+                                       BMOpSlot *slot = BMO_slot_get(op, slotname);
 
-                               BMO_CopySlot(op2, op, slotname2, slotname);
-                               state = 1;
-                               break;
-                       }
-                       case 'i':
-                       case 'd':
-                               BMO_Set_Int(op, slotname, va_arg(vlist, int));
-                               state = 1;
-                               break;
-                       case 'p':
-                               BMO_Set_Pnt(op, slotname, va_arg(vlist, void *));
-                               state = 1;
-                               break;
-                       case 'f':
-                       case 'h':
-                       case 'a':
-                               type = *fmt;
+                                       slot->data.buf = BLI_memarena_alloc(op->arena, sizeof(void *) * 4);
+                                       slot->len = 1;
+                                       *((void **)slot->data.buf) = ele;
+
+                                       state = 1;
+                                       break;
+                               }
+                               case 's': {
+                                       BMOperator *op2 = va_arg(vlist, void *);
+                                       const char *slotname2 = va_arg(vlist, char *);
 
-                               if (nextc(fmt) == ' ' || nextc(fmt) == '\t' || nextc(fmt) == '\0') {
-                                       BMO_Set_Float(op, slotname, va_arg(vlist, double));
+                                       BMO_slot_copy(op2, op, slotname2, slotname);
+                                       state = 1;
+                                       break;
                                }
-                               else {
-                                       ret = 0;
-                                       stop = 0;
-                                       while (1) {
-                                       switch (nextc(fmt)) {
-                                               case 'f': ret |= BM_FACE; break;
-                                               case 'e': ret |= BM_EDGE; break;
-                                               case 'v': ret |= BM_VERT; break;
-                                               default:
-                                                       stop = 1;
-                                                       break;
+                               case 'i':
+                                       BMO_slot_int_set(op, slotname, va_arg(vlist, int));
+                                       state = 1;
+                                       break;
+                               case 'b':
+                                       BMO_slot_bool_set(op, slotname, va_arg(vlist, int));
+                                       state = 1;
+                                       break;
+                               case 'p':
+                                       BMO_slot_ptr_set(op, slotname, va_arg(vlist, void *));
+                                       state = 1;
+                                       break;
+                               case 'f':
+                               case 'F':
+                               case 'h':
+                               case 'H':
+                               case 'a':
+                                       type = *fmt;
+
+                                       if (NEXT_CHAR(fmt) == ' ' || NEXT_CHAR(fmt) == '\0') {
+                                               BMO_slot_float_set(op, slotname, va_arg(vlist, double));
                                        }
-                                       if (stop) break;
-                                       fmt++;
+                                       else {
+                                               htype = 0;
+                                               stop = 0;
+                                               while (1) {
+                                                       switch (NEXT_CHAR(fmt)) {
+                                                               case 'f': htype |= BM_FACE; break;
+                                                               case 'e': htype |= BM_EDGE; break;
+                                                               case 'v': htype |= BM_VERT; break;
+                                                               default:
+                                                                       stop = 1;
+                                                                       break;
+                                                       }
+                                                       if (stop) {
+                                                               break;
+                                                       }
+
+                                                       fmt++;
+                                               }
+
+                                               if (type == 'h') {
+                                                       BMO_slot_buffer_from_enabled_hflag(bm, op, slotname, htype, va_arg(vlist, int));
+                                               }
+                                               else if (type == 'H') {
+                                                       BMO_slot_buffer_from_disabled_hflag(bm, op, slotname, htype, va_arg(vlist, int));
+                                               }
+                                               else if (type == 'a') {
+                                                       BMO_slot_buffer_from_all(bm, op, slotname, htype);
+                                               }
+                                               else if (type == 'f') {
+                                                       BMO_slot_buffer_from_enabled_flag(bm, op, slotname, htype, va_arg(vlist, int));
+                                               }
+                                               else if (type == 'F') {
+                                                       BMO_slot_buffer_from_disabled_flag(bm, op, slotname, htype, va_arg(vlist, int));
+                                               }
                                        }
-                                       
-                                       if (type == 'h')
-                                               BMO_HeaderFlag_To_Slot(bm, op, 
-                                                  slotname, va_arg(vlist, int), ret);
-                                       else if (type == 'a')
-                                               BMO_All_To_Slot(bm, op, slotname, ret);
-                                       else
-                                               BMO_Flag_To_Slot(bm, op, slotname, 
-                                                            va_arg(vlist, int), ret);
-                               }
 
-                               state = 1;
-                               break;
-                       default:
-                               fprintf(stderr,
-                                       "%s: unrecognized bmop format char: %c, %d in '%s'\n",
-                                       __func__, *fmt, (int)(fmt-ofmt), ofmt);
-                               break;
+                                       state = 1;
+                                       break;
+                               default:
+                                       fprintf(stderr,
+                                               "%s: unrecognized bmop format char: %c, %d in '%s'\n",
+                                               __func__, *fmt, (int)(fmt - ofmt), ofmt);
+                                       break;
                        }
                }
                fmt++;
        }
 
        MEM_freeN(ofmt);
-       return 1;
+       return TRUE;
 error:
 
        /* non urgent todo - explain exactly what is failing */
-       fprintf(stderr,
-               "%s: error parsing formatting string, %d in '%s'\n    see - %s:%d\n",
-               __func__, (int)(fmt-ofmt), _fmt, __FILE__, lineno);
+       fprintf(stderr, "%s: error parsing formatting string\n", __func__);
+
+       fprintf(stderr, "string: '%s', position %d\n", _fmt, (int)(fmt - ofmt));
+       fprintf(stderr, "         ");
+       {
+               int pos = (int)(fmt - ofmt);
+               int i;
+               for (i = 0; i < pos; i++) {
+                       fprintf(stderr, " ");
+               }
+               fprintf(stderr, "^\n");
+       }
+
+       fprintf(stderr, "source code:  %s:%d\n", __FILE__, lineno);
+
+       fprintf(stderr, "reason: %s\n", err_reason);
+
+
        MEM_freeN(ofmt);
 
-       BMO_Finish_Op(bm, op);
-       return 0;
+       BMO_op_finish(bm, op);
+       return FALSE;
 
 #undef GOTO_ERROR
 
 }
 
 
-int BMO_InitOpf(BMesh *bm, BMOperator *op, const char *fmt, ...)
+int BMO_op_initf(BMesh *bm, BMOperator *op, const char *fmt, ...)
 {
        va_list list;
 
        va_start(list, fmt);
-       if (!BMO_VInitOpf(bm, op, fmt, list)) {
+       if (!BMO_op_vinitf(bm, op, fmt, list)) {
                printf("%s: failed\n", __func__);
                va_end(list);
-               return 0;
+               return FALSE;
        }
        va_end(list);
 
-       return 1;
+       return TRUE;
 }
 
-int BMO_CallOpf(BMesh *bm, const char *fmt, ...)
+int BMO_op_callf(BMesh *bm, const char *fmt, ...)
 {
        va_list list;
        BMOperator op;
 
        va_start(list, fmt);
-       if (!BMO_VInitOpf(bm, &op, fmt, list)) {
+       if (!BMO_op_vinitf(bm, &op, fmt, list)) {
                printf("%s: failed, format is:\n    \"%s\"\n", __func__, fmt);
                va_end(list);
-               return 0;
+               return FALSE;
        }
 
-       BMO_Exec_Op(bm, &op);
-       BMO_Finish_Op(bm, &op);
+       BMO_op_exec(bm, &op);
+       BMO_op_finish(bm, &op);
 
        va_end(list);
-       return 1;
-}
-
-/*
- * BMO_TOGGLEFLAG
- *
- * Toggles a flag for a certain element
- */
-#ifdef BMO_ToggleFlag
-#undef BMO_ToggleFlag
-#endif
-static void BMO_ToggleFlag(BMesh *bm, void *element, int flag)
-{
-       BMHeader *head = element;
-       head->flags[bm->stackdepth - 1].f ^= flag;
-}
-
-/*
- * BMO_SETFLAG
- *
- * Sets a flag for a certain element
- */
-#ifdef BMO_SetFlag
-#undef BMO_SetFlag
-#endif
-static void BMO_SetFlag(BMesh *bm, void *element, const int flag)
-{
-       BMHeader *head = element;
-       head->flags[bm->stackdepth - 1].f |= flag;
-}
-
-/*
- * BMO_CLEARFLAG
- *
- * Clears a specific flag from a given element
- */
-#ifdef BMO_ClearFlag
-#undef BMO_ClearFlag
-#endif
-static void BMO_ClearFlag(BMesh *bm, void *element, const int flag)
-{
-       BMHeader *head = element;
-       head->flags[bm->stackdepth - 1].f &= ~flag;
-}
-
-/*
- * BMO_TESTFLAG
- *
- * Tests whether or not a flag is set for a specific element
- *
- */
-#ifdef BMO_TestFlag
-#undef BMO_TestFlag
-#endif
-static int BMO_TestFlag(BMesh *bm, void *element, int flag)
-{
-       BMHeader *head = element;
-       if (head->flags[bm->stackdepth - 1].f & flag)
-               return 1;
-       return 0;
+       return TRUE;
 }