Cleanup: rename mcords to mcoords

- 'coords' is an abbreviation for coordinates, not 'cords'.
- Rename 'moves' to 'coords_len'.

19 files changed, 249 insertions, 218 deletions

diff --git a/source/blender/blenlib/BLI_lasso_2d.h b/source/blender/blenlib/BLI_lasso_2d.h
index 56db360dab0..fb661c41784 100644
--- a/source/blender/blenlib/BLI_lasso_2d.h
+++ b/source/blender/blenlib/BLI_lasso_2d.h
@@ -30,14 +30,14 @@ extern "C" {
 
 struct rcti;
 
-void BLI_lasso_boundbox(struct rcti *rect, const int mcords[][2], const unsigned int moves);
-bool BLI_lasso_is_point_inside(const int mcords[][2],
-                               const unsigned int moves,
+void BLI_lasso_boundbox(struct rcti *rect, const int mcoords[][2], const unsigned int mcoords_len);
+bool BLI_lasso_is_point_inside(const int mcoords[][2],
+                               const unsigned int mcoords_len,
                                const int sx,
                                const int sy,
                                const int error_value);
-bool BLI_lasso_is_edge_inside(const int mcords[][2],
-                              const unsigned int moves,
+bool BLI_lasso_is_edge_inside(const int mcoords[][2],
+                              const unsigned int mcoords_len,
                               int x0,
                               int y0,
                               int x1,
diff --git a/source/blender/blenlib/intern/lasso_2d.c b/source/blender/blenlib/intern/lasso_2d.c
index f1e9b1e655f..a01adf4fa6a 100644
--- a/source/blender/blenlib/intern/lasso_2d.c
+++ b/source/blender/blenlib/intern/lasso_2d.c
@@ -28,47 +28,47 @@
 
 #include "BLI_lasso_2d.h" /* own include */
 
-void BLI_lasso_boundbox(rcti *rect, const int mcords[][2], const unsigned int moves)
+void BLI_lasso_boundbox(rcti *rect, const int mcoords[][2], const unsigned int mcoords_len)
 {
   unsigned int a;
 
-  rect->xmin = rect->xmax = mcords[0][0];
-  rect->ymin = rect->ymax = mcords[0][1];
+  rect->xmin = rect->xmax = mcoords[0][0];
+  rect->ymin = rect->ymax = mcoords[0][1];
 
-  for (a = 1; a < moves; a++) {
-    if (mcords[a][0] < rect->xmin) {
-      rect->xmin = mcords[a][0];
+  for (a = 1; a < mcoords_len; a++) {
+    if (mcoords[a][0] < rect->xmin) {
+      rect->xmin = mcoords[a][0];
     }
-    else if (mcords[a][0] > rect->xmax) {
-      rect->xmax = mcords[a][0];
+    else if (mcoords[a][0] > rect->xmax) {
+      rect->xmax = mcoords[a][0];
     }
-    if (mcords[a][1] < rect->ymin) {
-      rect->ymin = mcords[a][1];
+    if (mcoords[a][1] < rect->ymin) {
+      rect->ymin = mcoords[a][1];
     }
-    else if (mcords[a][1] > rect->ymax) {
-      rect->ymax = mcords[a][1];
+    else if (mcoords[a][1] > rect->ymax) {
+      rect->ymax = mcoords[a][1];
     }
   }
 }
 
-bool BLI_lasso_is_point_inside(const int mcords[][2],
-                               const unsigned int moves,
+bool BLI_lasso_is_point_inside(const int mcoords[][2],
+                               const unsigned int mcoords_len,
                                const int sx,
                                const int sy,
                                const int error_value)
 {
-  if (sx == error_value || moves == 0) {
+  if (sx == error_value || mcoords_len == 0) {
     return false;
   }
   else {
     int pt[2] = {sx, sy};
-    return isect_point_poly_v2_int(pt, mcords, moves, true);
+    return isect_point_poly_v2_int(pt, mcoords, mcoords_len, true);
   }
 }
 
 /* edge version for lasso select. we assume boundbox check was done */
-bool BLI_lasso_is_edge_inside(const int mcords[][2],
-                              const unsigned int moves,
+bool BLI_lasso_is_edge_inside(const int mcoords[][2],
+                              const unsigned int mcoords_len,
                               int x0,
                               int y0,
                               int x1,
@@ -76,27 +76,27 @@ bool BLI_lasso_is_edge_inside(const int mcords[][2],
                               const int error_value)
 {
 
-  if (x0 == error_value || x1 == error_value || moves == 0) {
+  if (x0 == error_value || x1 == error_value || mcoords_len == 0) {
     return false;
   }
 
   const int v1[2] = {x0, y0}, v2[2] = {x1, y1};
 
   /* check points in lasso */
-  if (BLI_lasso_is_point_inside(mcords, moves, v1[0], v1[1], error_value)) {
+  if (BLI_lasso_is_point_inside(mcoords, mcoords_len, v1[0], v1[1], error_value)) {
     return true;
   }
-  if (BLI_lasso_is_point_inside(mcords, moves, v2[0], v2[1], error_value)) {
+  if (BLI_lasso_is_point_inside(mcoords, mcoords_len, v2[0], v2[1], error_value)) {
     return true;
   }
 
   /* no points in lasso, so we have to intersect with lasso edge */
 
-  if (isect_seg_seg_v2_int(mcords[0], mcords[moves - 1], v1, v2) > 0) {
+  if (isect_seg_seg_v2_int(mcoords[0], mcoords[mcoords_len - 1], v1, v2) > 0) {
     return true;
   }
-  for (unsigned int a = 0; a < moves - 1; a++) {
-    if (isect_seg_seg_v2_int(mcords[a], mcords[a + 1], v1, v2) > 0) {
+  for (unsigned int a = 0; a < mcoords_len - 1; a++) {
+    if (isect_seg_seg_v2_int(mcoords[a], mcoords[a + 1], v1, v2) > 0) {
       return true;
     }
   }
diff --git a/source/blender/editors/animation/keyframes_edit.c b/source/blender/editors/animation/keyframes_edit.c
index e22fddc6d67..2dae4e8b4c5 100644
--- a/source/blender/editors/animation/keyframes_edit.c
+++ b/source/blender/editors/animation/keyframes_edit.c
@@ -633,7 +633,7 @@ bool keyframe_region_lasso_test(const KeyframeEdit_LassoData *data_lasso, const
     BLI_rctf_transform_pt_v(data_lasso->rectf_view, data_lasso->rectf_scaled, xy_view, xy);
 
     if (BLI_lasso_is_point_inside(
-            data_lasso->mcords, data_lasso->mcords_tot, xy_view[0], xy_view[1], INT_MAX)) {
+            data_lasso->mcoords, data_lasso->mcoords_len, xy_view[0], xy_view[1], INT_MAX)) {
       return true;
     }
   }
diff --git a/source/blender/editors/gpencil/gpencil_edit.c b/source/blender/editors/gpencil/gpencil_edit.c
index 77e45642939..4a4ade4e98f 100644
--- a/source/blender/editors/gpencil/gpencil_edit.c
+++ b/source/blender/editors/gpencil/gpencil_edit.c
@@ -4547,8 +4547,8 @@ void GPENCIL_OT_stroke_smooth(wmOperatorType *ot)
 /* smart stroke cutter for trimming stroke ends */
 struct GP_SelectLassoUserData {
   rcti rect;
-  const int (*mcords)[2];
-  int mcords_len;
+  const int (*mcoords)[2];
+  int mcoords_len;
 };
 
 static bool gpencil_test_lasso(bGPDstroke *gps,
@@ -4564,7 +4564,7 @@ static bool gpencil_test_lasso(bGPDstroke *gps,
   gp_point_to_xy(gsc, gps, &pt2, &x0, &y0);
   /* test if in lasso */
   return ((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(&data->rect, x0, y0) &&
-          BLI_lasso_is_point_inside(data->mcords, data->mcords_len, x0, y0, INT_MAX));
+          BLI_lasso_is_point_inside(data->mcoords, data->mcoords_len, x0, y0, INT_MAX));
 }
 
 typedef bool (*GPencilTestFn)(bGPDstroke *gps,
@@ -4742,19 +4742,19 @@ static int gpencil_cutter_exec(bContext *C, wmOperator *op)
   }
 
   struct GP_SelectLassoUserData data = {0};
-  data.mcords = WM_gesture_lasso_path_to_array(C, op, &data.mcords_len);
+  data.mcoords = WM_gesture_lasso_path_to_array(C, op, &data.mcoords_len);
 
   /* Sanity check. */
-  if (data.mcords == NULL) {
+  if (data.mcoords == NULL) {
     return OPERATOR_PASS_THROUGH;
   }
 
   /* Compute boundbox of lasso (for faster testing later). */
-  BLI_lasso_boundbox(&data.rect, data.mcords, data.mcords_len);
+  BLI_lasso_boundbox(&data.rect, data.mcoords, data.mcoords_len);
 
   gpencil_cutter_lasso_select(C, op, gpencil_test_lasso, &data);
 
-  MEM_freeN((void *)data.mcords);
+  MEM_freeN((void *)data.mcoords);
 
   return OPERATOR_FINISHED;
 }
diff --git a/source/blender/editors/gpencil/gpencil_select.c b/source/blender/editors/gpencil/gpencil_select.c
index e25576f32aa..69d22b52ded 100644
--- a/source/blender/editors/gpencil/gpencil_select.c
+++ b/source/blender/editors/gpencil/gpencil_select.c
@@ -1327,8 +1327,8 @@ void GPENCIL_OT_select_box(wmOperatorType *ot)
 
 struct GP_SelectLassoUserData {
   rcti rect;
-  const int (*mcords)[2];
-  int mcords_len;
+  const int (*mcoords)[2];
+  int mcoords_len;
 };
 
 static bool gpencil_test_lasso(bGPDstroke *gps,
@@ -1344,25 +1344,25 @@ static bool gpencil_test_lasso(bGPDstroke *gps,
   gp_point_to_xy(gsc, gps, &pt2, &x0, &y0);
   /* test if in lasso boundbox + within the lasso noose */
   return ((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(&data->rect, x0, y0) &&
-          BLI_lasso_is_point_inside(data->mcords, data->mcords_len, x0, y0, INT_MAX));
+          BLI_lasso_is_point_inside(data->mcoords, data->mcoords_len, x0, y0, INT_MAX));
 }
 
 static int gpencil_lasso_select_exec(bContext *C, wmOperator *op)
 {
   struct GP_SelectLassoUserData data = {0};
-  data.mcords = WM_gesture_lasso_path_to_array(C, op, &data.mcords_len);
+  data.mcoords = WM_gesture_lasso_path_to_array(C, op, &data.mcoords_len);
 
   /* Sanity check. */
-  if (data.mcords == NULL) {
+  if (data.mcoords == NULL) {
     return OPERATOR_PASS_THROUGH;
   }
 
   /* Compute boundbox of lasso (for faster testing later). */
-  BLI_lasso_boundbox(&data.rect, data.mcords, data.mcords_len);
+  BLI_lasso_boundbox(&data.rect, data.mcoords, data.mcoords_len);
 
   int ret = gpencil_generic_select_exec(C, op, gpencil_test_lasso, &data);
 
-  MEM_freeN((void *)data.mcords);
+  MEM_freeN((void *)data.mcoords);
 
   return ret;
 }
diff --git a/source/blender/editors/include/ED_keyframes_edit.h b/source/blender/editors/include/ED_keyframes_edit.h
index 3ae0c254000..3ae864721e8 100644
--- a/source/blender/editors/include/ED_keyframes_edit.h
+++ b/source/blender/editors/include/ED_keyframes_edit.h
@@ -106,8 +106,8 @@ typedef enum eEditKeyframes_Mirror {
 typedef struct KeyframeEdit_LassoData {
   rctf *rectf_scaled;
   const rctf *rectf_view;
-  const int (*mcords)[2];
-  int mcords_tot;
+  const int (*mcoords)[2];
+  int mcoords_len;
 } KeyframeEdit_LassoData;
 
 /* use with BEZT_OK_REGION_CIRCLE */
diff --git a/source/blender/editors/include/ED_particle.h b/source/blender/editors/include/ED_particle.h
index c8a4dc5b49d..6959cac7efe 100644
--- a/source/blender/editors/include/ED_particle.h
+++ b/source/blender/editors/include/ED_particle.h
@@ -71,7 +71,7 @@ bool PE_mouse_particles(
 bool PE_box_select(struct bContext *C, const struct rcti *rect, const int sel_op);
 bool PE_circle_select(struct bContext *C, const int sel_op, const int mval[2], float rad);
 int PE_lasso_select(struct bContext *C,
-                    const int mcords[][2],
+                    const int mcoords[][2],
                     const short moves,
                     const int sel_op);
 bool PE_deselect_all_visible_ex(struct PTCacheEdit *edit);
diff --git a/source/blender/editors/mask/mask_select.c b/source/blender/editors/mask/mask_select.c
index a6dece91eb0..416c1dc6e49 100644
--- a/source/blender/editors/mask/mask_select.c
+++ b/source/blender/editors/mask/mask_select.c
@@ -521,8 +521,8 @@ void MASK_OT_select_box(wmOperatorType *ot)
  * \{ */
 
 static bool do_lasso_select_mask(bContext *C,
-                                 const int mcords[][2],
-                                 short moves,
+                                 const int mcoords[][2],
+                                 short mcoords_len,
                                  const eSelectOp sel_op)
 {
   ScrArea *area = CTX_wm_area(C);
@@ -540,7 +540,7 @@ static bool do_lasso_select_mask(bContext *C,
   }
 
   /* get rectangle from operator */
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
   /* do actual selection */
   LISTBASE_FOREACH (MaskLayer *, mask_layer, &mask->masklayers) {
@@ -573,7 +573,7 @@ static bool do_lasso_select_mask(bContext *C,
                                    &screen_co[1]);
 
         if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
-            BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], INT_MAX)) {
+            BLI_lasso_is_point_inside(mcoords, mcoords_len, screen_co[0], screen_co[1], INT_MAX)) {
           BKE_mask_point_select_set(point, select);
           BKE_mask_point_select_set_handle(point, MASK_WHICH_HANDLE_BOTH, select);
           changed = true;
@@ -594,14 +594,14 @@ static bool do_lasso_select_mask(bContext *C,
 
 static int clip_lasso_select_exec(bContext *C, wmOperator *op)
 {
-  int mcords_tot;
-  const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot);
+  int mcoords_len;
+  const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
 
-  if (mcords) {
+  if (mcoords) {
     const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
-    do_lasso_select_mask(C, mcords, mcords_tot, sel_op);
+    do_lasso_select_mask(C, mcoords, mcoords_len, sel_op);
 
-    MEM_freeN((void *)mcords);
+    MEM_freeN((void *)mcoords);
 
     return OPERATOR_FINISHED;
   }
diff --git a/source/blender/editors/physics/particle_edit.c b/source/blender/editors/physics/particle_edit.c
index 3e2b18c8c9b..604f66002c2 100644
--- a/source/blender/editors/physics/particle_edit.c
+++ b/source/blender/editors/physics/particle_edit.c
@@ -2252,7 +2252,7 @@ bool PE_circle_select(bContext *C, const int sel_op, const int mval[2], float ra
 
 /************************ lasso select operator ************************/
 
-int PE_lasso_select(bContext *C, const int mcords[][2], const short moves, const int sel_op)
+int PE_lasso_select(bContext *C, const int mcoords[][2], const short mcoords_len, const int sel_op)
 {
   Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
   Scene *scene = CTX_data_scene(C);
@@ -2296,7 +2296,8 @@ int PE_lasso_select(bContext *C, const int mcords[][2], const short moves, const
         const bool is_inside =
             ((ED_view3d_project_int_global(region, co, screen_co, V3D_PROJ_TEST_CLIP_WIN) ==
               V3D_PROJ_RET_OK) &&
-             BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], IS_CLIPPED) &&
+             BLI_lasso_is_point_inside(
+                 mcoords, mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED) &&
              key_test_depth(&data, co, screen_co));
         const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
         if (sel_op_result != -1) {
@@ -2315,7 +2316,8 @@ int PE_lasso_select(bContext *C, const int mcords[][2], const short moves, const
         const bool is_inside =
             ((ED_view3d_project_int_global(region, co, screen_co, V3D_PROJ_TEST_CLIP_WIN) ==
               V3D_PROJ_RET_OK) &&
-             BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], IS_CLIPPED) &&
+             BLI_lasso_is_point_inside(
+                 mcoords, mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED) &&
              key_test_depth(&data, co, screen_co));
         const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
         if (sel_op_result != -1) {
diff --git a/source/blender/editors/sculpt_paint/paint_mask.c b/source/blender/editors/sculpt_paint/paint_mask.c
index c235a4386ec..89cf090b7c6 100644
--- a/source/blender/editors/sculpt_paint/paint_mask.c
+++ b/source/blender/editors/sculpt_paint/paint_mask.c
@@ -456,10 +456,10 @@ static void mask_gesture_lasso_task_cb(void *__restrict userdata,
 
 static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
 {
-  int mcords_tot;
-  const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot);
+  int mcoords_len;
+  const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
 
-  if (mcords) {
+  if (mcoords) {
     Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
     float clip_planes[4][4], clip_planes_final[4][4];
     BoundBox bb;
@@ -485,7 +485,7 @@ static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
     ob = vc.obact;
     ED_view3d_ob_project_mat_get(vc.rv3d, ob, data.projviewobjmat);
 
-    BLI_lasso_boundbox(&data.rect, mcords, mcords_tot);
+    BLI_lasso_boundbox(&data.rect, mcoords, mcoords_len);
     data.width = data.rect.xmax - data.rect.xmin;
     data.px = BLI_BITMAP_NEW(data.width * (data.rect.ymax - data.rect.ymin), __func__);
 
@@ -493,8 +493,8 @@ static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
                                   data.rect.ymin,
                                   data.rect.xmax,
                                   data.rect.ymax,
-                                  mcords,
-                                  mcords_tot,
+                                  mcoords,
+                                  mcoords_len,
                                   mask_lasso_px_cb,
                                   &data);
 
@@ -551,7 +551,7 @@ static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
     SCULPT_undo_push_end();
 
     ED_region_tag_redraw(vc.region);
-    MEM_freeN((void *)mcords);
+    MEM_freeN((void *)mcoords);
     MEM_freeN(data.px);
 
     WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
diff --git a/source/blender/editors/space_action/action_select.c b/source/blender/editors/space_action/action_select.c
index 26c29d6cbe7..bbb68f632fb 100644
--- a/source/blender/editors/space_action/action_select.c
+++ b/source/blender/editors/space_action/action_select.c
@@ -793,8 +793,8 @@ static int actkeys_lassoselect_exec(bContext *C, wmOperator *op)
   }
 
   data_lasso.rectf_view = &rect_fl;
-  data_lasso.mcords = WM_gesture_lasso_path_to_array(C, op, &data_lasso.mcords_tot);
-  if (data_lasso.mcords == NULL) {
+  data_lasso.mcoords = WM_gesture_lasso_path_to_array(C, op, &data_lasso.mcoords_len);
+  if (data_lasso.mcoords == NULL) {
     return OPERATOR_CANCELLED;
   }
 
@@ -805,13 +805,13 @@ static int actkeys_lassoselect_exec(bContext *C, wmOperator *op)
   }
 
   /* get settings from operator */
-  BLI_lasso_boundbox(&rect, data_lasso.mcords, data_lasso.mcords_tot);
+  BLI_lasso_boundbox(&rect, data_lasso.mcoords, data_lasso.mcoords_len);
   BLI_rctf_rcti_copy(&rect_fl, &rect);
 
   /* apply box_select action */
   region_select_action_keys(&ac, &rect_fl, BEZT_OK_CHANNEL_LASSO, selectmode, &data_lasso);
 
-  MEM_freeN((void *)data_lasso.mcords);
+  MEM_freeN((void *)data_lasso.mcoords);
 
   /* send notifier that keyframe selection has changed */
   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
diff --git a/source/blender/editors/space_clip/tracking_select.c b/source/blender/editors/space_clip/tracking_select.c
index c2a4ebdfc63..7f58f30d2d2 100644
--- a/source/blender/editors/space_clip/tracking_select.c
+++ b/source/blender/editors/space_clip/tracking_select.c
@@ -598,8 +598,8 @@ void CLIP_OT_select_box(wmOperatorType *ot)
 /********************** lasso select operator *********************/
 
 static int do_lasso_select_marker(bContext *C,
-                                  const int mcords[][2],
-                                  const short moves,
+                                  const int mcoords[][2],
+                                  const short mcoords_len,
                                   bool select)
 {
   SpaceClip *sc = CTX_wm_space_clip(C);
@@ -616,7 +616,7 @@ static int do_lasso_select_marker(bContext *C,
   int framenr = ED_space_clip_get_clip_frame_number(sc);
 
   /* get rectangle from operator */
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
   /* do actual selection */
   track = tracksbase->first;
@@ -631,7 +631,8 @@ static int do_lasso_select_marker(bContext *C,
         ED_clip_point_stable_pos__reverse(sc, region, marker->pos, screen_co);
 
         if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
-            BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], V2D_IS_CLIPPED)) {
+            BLI_lasso_is_point_inside(
+                mcoords, mcoords_len, screen_co[0], screen_co[1], V2D_IS_CLIPPED)) {
           if (select) {
             BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);
           }
@@ -659,7 +660,8 @@ static int do_lasso_select_marker(bContext *C,
         ED_clip_point_stable_pos__reverse(sc, region, plane_marker->corners[i], screen_co);
 
         if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
-            BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], V2D_IS_CLIPPED)) {
+            BLI_lasso_is_point_inside(
+                mcoords, mcoords_len, screen_co[0], screen_co[1], V2D_IS_CLIPPED)) {
           if (select) {
             plane_track->flag |= SELECT;
           }
@@ -685,10 +687,10 @@ static int do_lasso_select_marker(bContext *C,
 
 static int clip_lasso_select_exec(bContext *C, wmOperator *op)
 {
-  int mcords_tot;
-  const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot);
+  int mcoords_len;
+  const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
 
-  if (mcords) {
+  if (mcoords) {
     const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
     const bool select = (sel_op != SEL_OP_SUB);
     if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
@@ -696,9 +698,9 @@ static int clip_lasso_select_exec(bContext *C, wmOperator *op)
       ED_clip_select_all(sc, SEL_DESELECT, NULL);
     }
 
-    do_lasso_select_marker(C, mcords, mcords_tot, select);
+    do_lasso_select_marker(C, mcoords, mcoords_len, select);
 
-    MEM_freeN((void *)mcords);
+    MEM_freeN((void *)mcoords);
 
     return OPERATOR_FINISHED;
   }
diff --git a/source/blender/editors/space_graph/graph_select.c b/source/blender/editors/space_graph/graph_select.c
index a2e9ba86dec..ae435b5624a 100644
--- a/source/blender/editors/space_graph/graph_select.c
+++ b/source/blender/editors/space_graph/graph_select.c
@@ -760,8 +760,8 @@ static int graphkeys_lassoselect_exec(bContext *C, wmOperator *op)
   }
 
   data_lasso.rectf_view = &rect_fl;
-  data_lasso.mcords = WM_gesture_lasso_path_to_array(C, op, &data_lasso.mcords_tot);
-  if (data_lasso.mcords == NULL) {
+  data_lasso.mcoords = WM_gesture_lasso_path_to_array(C, op, &data_lasso.mcoords_len);
+  if (data_lasso.mcoords == NULL) {
     return OPERATOR_CANCELLED;
   }
 
@@ -782,13 +782,13 @@ static int graphkeys_lassoselect_exec(bContext *C, wmOperator *op)
   }
 
   /* get settings from operator */
-  BLI_lasso_boundbox(&rect, data_lasso.mcords, data_lasso.mcords_tot);
+  BLI_lasso_boundbox(&rect, data_lasso.mcoords, data_lasso.mcoords_len);
   BLI_rctf_rcti_copy(&rect_fl, &rect);
 
   /* apply box_select action */
   box_select_graphkeys(&ac, &rect_fl, BEZT_OK_REGION_LASSO, selectmode, incl_handles, &data_lasso);
 
-  MEM_freeN((void *)data_lasso.mcords);
+  MEM_freeN((void *)data_lasso.mcoords);
 
   /* send notifier that keyframe selection has changed */
   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);
diff --git a/source/blender/editors/space_node/node_select.c b/source/blender/editors/space_node/node_select.c
index 50c32da4b5a..547abaf8809 100644
--- a/source/blender/editors/space_node/node_select.c
+++ b/source/blender/editors/space_node/node_select.c
@@ -766,7 +766,10 @@ static int node_lasso_select_invoke(bContext *C, wmOperator *op, const wmEvent *
   return WM_gesture_lasso_invoke(C, op, event);
 }
 
-static bool do_lasso_select_node(bContext *C, const int mcords[][2], short moves, eSelectOp sel_op)
+static bool do_lasso_select_node(bContext *C,
+                                 const int mcoords[][2],
+                                 short mcoords_len,
+                                 eSelectOp sel_op)
 {
   SpaceNode *snode = CTX_wm_space_node(C);
   bNode *node;
@@ -783,7 +786,7 @@ static bool do_lasso_select_node(bContext *C, const int mcords[][2], short moves
   }
 
   /* get rectangle from operator */
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
   /* do actual selection */
   for (node = snode->edittree->nodes.first; node; node = node->next) {
@@ -799,7 +802,7 @@ static bool do_lasso_select_node(bContext *C, const int mcords[][2], short moves
     if (UI_view2d_view_to_region_clip(
             &region->v2d, cent[0], cent[1], &screen_co[0], &screen_co[1]) &&
         BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
-        BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], INT_MAX)) {
+        BLI_lasso_is_point_inside(mcoords, mcoords_len, screen_co[0], screen_co[1], INT_MAX)) {
       nodeSetSelected(node, select);
       changed = true;
     }
@@ -814,15 +817,15 @@ static bool do_lasso_select_node(bContext *C, const int mcords[][2], short moves
 
 static int node_lasso_select_exec(bContext *C, wmOperator *op)
 {
-  int mcords_tot;
-  const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot);
+  int mcoords_len;
+  const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
 
-  if (mcords) {
+  if (mcoords) {
     const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
 
-    do_lasso_select_node(C, mcords, mcords_tot, sel_op);
+    do_lasso_select_node(C, mcoords, mcoords_len, sel_op);
 
-    MEM_freeN((void *)mcords);
+    MEM_freeN((void *)mcoords);
 
     return OPERATOR_FINISHED;
   }
diff --git a/source/blender/editors/space_view3d/view3d_select.c b/source/blender/editors/space_view3d/view3d_select.c
index 4864d3a3d4c..97e7cf32a41 100644
--- a/source/blender/editors/space_view3d/view3d_select.c
+++ b/source/blender/editors/space_view3d/view3d_select.c
@@ -408,8 +408,8 @@ typedef struct LassoSelectUserData {
   const rcti *rect;
   const rctf *rect_fl;
   rctf _rect_fl;
-  const int (*mcords)[2];
-  int moves;
+  const int (*mcoords)[2];
+  int mcoords_len;
   eSelectOp sel_op;
 
   /* runtime */
@@ -421,8 +421,8 @@ typedef struct LassoSelectUserData {
 static void view3d_userdata_lassoselect_init(LassoSelectUserData *r_data,
                                              ViewContext *vc,
                                              const rcti *rect,
-                                             const int (*mcords)[2],
-                                             const int moves,
+                                             const int (*mcoords)[2],
+                                             const int mcoords_len,
                                              const eSelectOp sel_op)
 {
   r_data->vc = vc;
@@ -431,8 +431,8 @@ static void view3d_userdata_lassoselect_init(LassoSelectUserData *r_data,
   r_data->rect_fl = &r_data->_rect_fl;
   BLI_rctf_rcti_copy(&r_data->_rect_fl, rect);
 
-  r_data->mcords = mcords;
-  r_data->moves = moves;
+  r_data->mcoords = mcoords;
+  r_data->mcoords_len = mcoords_len;
   r_data->sel_op = sel_op;
 
   /* runtime */
@@ -527,7 +527,8 @@ static void do_lasso_select_pose__do_tag(void *userData,
     if (screen_co_a[0] != IS_CLIPPED) {
       points_proj_tot++;
       if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_a)) &&
-          BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_a), INT_MAX)) {
+          BLI_lasso_is_point_inside(
+              data->mcoords, data->mcoords_len, UNPACK2(screen_co_a), INT_MAX)) {
         is_point_done = true;
       }
     }
@@ -536,22 +537,28 @@ static void do_lasso_select_pose__do_tag(void *userData,
     if (screen_co_b[0] != IS_CLIPPED) {
       points_proj_tot++;
       if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_b)) &&
-          BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_b), INT_MAX)) {
+          BLI_lasso_is_point_inside(
+              data->mcoords, data->mcoords_len, UNPACK2(screen_co_b), INT_MAX)) {
         is_point_done = true;
       }
     }
 
     /* if one of points selected, we skip the bone itself */
-    if ((is_point_done == true) ||
-        ((is_point_done == false) && (points_proj_tot == 2) &&
-         BLI_lasso_is_edge_inside(
-             data->mcords, data->moves, UNPACK2(screen_co_a), UNPACK2(screen_co_b), INT_MAX))) {
+    if ((is_point_done == true) || ((is_point_done == false) && (points_proj_tot == 2) &&
+                                    BLI_lasso_is_edge_inside(data->mcoords,
+                                                             data->mcoords_len,
+                                                             UNPACK2(screen_co_a),
+                                                             UNPACK2(screen_co_b),
+                                                             INT_MAX))) {
       pchan->bone->flag |= BONE_DONE;
     }
     data->is_changed |= is_point_done;
   }
 }
-static void do_lasso_tag_pose(ViewContext *vc, Object *ob, const int mcords[][2], short moves)
+static void do_lasso_tag_pose(ViewContext *vc,
+                              Object *ob,
+                              const int mcoords[][2],
+                              short mcoords_len)
 {
   ViewContext vc_tmp;
   LassoSelectUserData data;
@@ -564,9 +571,9 @@ static void do_lasso_tag_pose(ViewContext *vc, Object *ob, const int mcords[][2]
   vc_tmp = *vc;
   vc_tmp.obact = ob;
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
-  view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, 0);
+  view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, 0);
 
   ED_view3d_init_mats_rv3d(vc_tmp.obact, vc->rv3d);
 
@@ -574,8 +581,8 @@ static void do_lasso_tag_pose(ViewContext *vc, Object *ob, const int mcords[][2]
 }
 
 static bool do_lasso_select_objects(ViewContext *vc,
-                                    const int mcords[][2],
-                                    const short moves,
+                                    const int mcoords[][2],
+                                    const short mcoords_len,
                                     const eSelectOp sel_op)
 {
   View3D *v3d = vc->v3d;
@@ -591,7 +598,7 @@ static bool do_lasso_select_objects(ViewContext *vc,
       const bool is_select = base->flag & BASE_SELECTED;
       const bool is_inside = ((ED_view3d_project_base(vc->region, base) == V3D_PROJ_RET_OK) &&
                               BLI_lasso_is_point_inside(
-                                  mcords, moves, base->sx, base->sy, IS_CLIPPED));
+                                  mcoords, mcoords_len, base->sx, base->sy, IS_CLIPPED));
       const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
       if (sel_op_result != -1) {
         ED_object_base_select(base, sel_op_result ? BA_SELECT : BA_DESELECT);
@@ -685,8 +692,8 @@ static bool do_pose_tag_select_op_exec(Base **bases, const uint bases_len, const
 }
 
 static bool do_lasso_select_pose(ViewContext *vc,
-                                 const int mcords[][2],
-                                 const short moves,
+                                 const int mcoords[][2],
+                                 const short mcoords_len,
                                  const eSelectOp sel_op)
 {
   uint bases_len;
@@ -695,7 +702,7 @@ static bool do_lasso_select_pose(ViewContext *vc,
   for (int i = 0; i < bases_len; i++) {
     Base *base_iter = bases[i];
     Object *ob_iter = base_iter->object;
-    do_lasso_tag_pose(vc, ob_iter, mcords, moves);
+    do_lasso_tag_pose(vc, ob_iter, mcoords, mcoords_len);
   }
 
   const bool changed_multi = do_pose_tag_select_op_exec(bases, bases_len, sel_op);
@@ -715,9 +722,10 @@ static void do_lasso_select_mesh__doSelectVert(void *userData,
 {
   LassoSelectUserData *data = userData;
   const bool is_select = BM_elem_flag_test(eve, BM_ELEM_SELECT);
-  const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
-                          BLI_lasso_is_point_inside(
-                              data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED));
+  const bool is_inside =
+      (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
+       BLI_lasso_is_point_inside(
+           data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED));
   const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
   if (sel_op_result != -1) {
     BM_vert_select_set(data->vc->em->bm, eve, sel_op_result);
@@ -746,8 +754,10 @@ static void do_lasso_select_mesh__doSelectEdge_pass0(void *user_data,
   const bool is_select = BM_elem_flag_test(eed, BM_ELEM_SELECT);
   const bool is_inside =
       (is_visible && edge_fully_inside_rect(data->rect_fl, screen_co_a, screen_co_b) &&
-       BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_a), IS_CLIPPED) &&
-       BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_b), IS_CLIPPED));
+       BLI_lasso_is_point_inside(
+           data->mcoords, data->mcoords_len, UNPACK2(screen_co_a), IS_CLIPPED) &&
+       BLI_lasso_is_point_inside(
+           data->mcoords, data->mcoords_len, UNPACK2(screen_co_b), IS_CLIPPED));
   const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
   if (sel_op_result != -1) {
     BM_edge_select_set(data->vc->em->bm, eed, sel_op_result);
@@ -770,8 +780,8 @@ static void do_lasso_select_mesh__doSelectEdge_pass1(void *user_data,
   }
 
   const bool is_select = BM_elem_flag_test(eed, BM_ELEM_SELECT);
-  const bool is_inside = (is_visible && BLI_lasso_is_edge_inside(data->mcords,
-                                                                 data->moves,
+  const bool is_inside = (is_visible && BLI_lasso_is_edge_inside(data->mcoords,
+                                                                 data->mcoords_len,
                                                                  UNPACK2(screen_co_a),
                                                                  UNPACK2(screen_co_b),
                                                                  IS_CLIPPED));
@@ -789,9 +799,10 @@ static void do_lasso_select_mesh__doSelectFace(void *userData,
 {
   LassoSelectUserData *data = userData;
   const bool is_select = BM_elem_flag_test(efa, BM_ELEM_SELECT);
-  const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
-                          BLI_lasso_is_point_inside(
-                              data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED));
+  const bool is_inside =
+      (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
+       BLI_lasso_is_point_inside(
+           data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED));
   const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
   if (sel_op_result != -1) {
     BM_face_select_set(data->vc->em->bm, efa, sel_op_result);
@@ -801,8 +812,8 @@ static void do_lasso_select_mesh__doSelectFace(void *userData,
 
 static bool do_lasso_select_mesh(ViewContext *vc,
                                  wmGenericUserData *wm_userdata,
-                                 const int mcords[][2],
-                                 short moves,
+                                 const int mcoords[][2],
+                                 short mcoords_len,
                                  const eSelectOp sel_op)
 {
   LassoSelectUserData data;
@@ -812,9 +823,9 @@ static bool do_lasso_select_mesh(ViewContext *vc,
   /* set editmesh */
   vc->em = BKE_editmesh_from_object(vc->obedit);
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
-  view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op);
+  view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
 
   if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
     if (vc->em->bm->totvertsel) {
@@ -836,7 +847,7 @@ static bool do_lasso_select_mesh(ViewContext *vc,
       editselect_buf_cache_init_with_generic_userdata(wm_userdata, vc, ts->selectmode);
       esel = wm_userdata->data;
       esel->select_bitmap = DRW_select_buffer_bitmap_from_poly(
-          vc->depsgraph, vc->region, vc->v3d, mcords, moves, &rect, NULL);
+          vc->depsgraph, vc->region, vc->v3d, mcoords, mcoords_len, &rect, NULL);
     }
   }
 
@@ -897,7 +908,7 @@ static void do_lasso_select_curve__doSelect(void *userData,
   LassoSelectUserData *data = userData;
 
   const bool is_inside = BLI_lasso_is_point_inside(
-      data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED);
+      data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED);
   if (bp) {
     const bool is_select = bp->f1 & SELECT;
     const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
@@ -930,16 +941,16 @@ static void do_lasso_select_curve__doSelect(void *userData,
 }
 
 static bool do_lasso_select_curve(ViewContext *vc,
-                                  const int mcords[][2],
-                                  short moves,
+                                  const int mcoords[][2],
+                                  short mcoords_len,
                                   const eSelectOp sel_op)
 {
   LassoSelectUserData data;
   rcti rect;
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
-  view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op);
+  view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
 
   if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
     Curve *curve = (Curve *)vc->obedit->data;
@@ -958,9 +969,10 @@ static void do_lasso_select_lattice__doSelect(void *userData, BPoint *bp, const
 {
   LassoSelectUserData *data = userData;
   const bool is_select = bp->f1 & SELECT;
-  const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
-                          BLI_lasso_is_point_inside(
-                              data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED));
+  const bool is_inside =
+      (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
+       BLI_lasso_is_point_inside(
+           data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED));
   const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
   if (sel_op_result != -1) {
     SET_FLAG_FROM_TEST(bp->f1, sel_op_result, SELECT);
@@ -968,16 +980,16 @@ static void do_lasso_select_lattice__doSelect(void *userData, BPoint *bp, const
   }
 }
 static bool do_lasso_select_lattice(ViewContext *vc,
-                                    const int mcords[][2],
-                                    short moves,
+                                    const int mcoords[][2],
+                                    short mcoords_len,
                                     const eSelectOp sel_op)
 {
   LassoSelectUserData data;
   rcti rect;
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
-  view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op);
+  view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
 
   if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
     data.is_changed |= ED_lattice_flags_set(vc->obedit, 0);
@@ -1002,7 +1014,8 @@ static void do_lasso_select_armature__doSelectBone(void *userData,
 
     if (screen_co_a[0] != IS_CLIPPED) {
       if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_a)) &&
-          BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_a), INT_MAX)) {
+          BLI_lasso_is_point_inside(
+              data->mcoords, data->mcoords_len, UNPACK2(screen_co_a), INT_MAX)) {
         is_inside_flag |= BONESEL_ROOT;
       }
     }
@@ -1012,7 +1025,8 @@ static void do_lasso_select_armature__doSelectBone(void *userData,
 
     if (screen_co_b[0] != IS_CLIPPED) {
       if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_b)) &&
-          BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_b), INT_MAX)) {
+          BLI_lasso_is_point_inside(
+              data->mcoords, data->mcoords_len, UNPACK2(screen_co_b), INT_MAX)) {
         is_inside_flag |= BONESEL_TIP;
       }
     }
@@ -1022,8 +1036,11 @@ static void do_lasso_select_armature__doSelectBone(void *userData,
 
     if (is_ignore_flag == 0) {
       if (is_inside_flag == (BONE_ROOTSEL | BONE_TIPSEL) ||
-          BLI_lasso_is_edge_inside(
-              data->mcords, data->moves, UNPACK2(screen_co_a), UNPACK2(screen_co_b), INT_MAX)) {
+          BLI_lasso_is_edge_inside(data->mcoords,
+                                   data->mcoords_len,
+                                   UNPACK2(screen_co_a),
+                                   UNPACK2(screen_co_b),
+                                   INT_MAX)) {
         is_inside_flag |= BONESEL_BONE;
       }
     }
@@ -1033,16 +1050,16 @@ static void do_lasso_select_armature__doSelectBone(void *userData,
 }
 
 static bool do_lasso_select_armature(ViewContext *vc,
-                                     const int mcords[][2],
-                                     short moves,
+                                     const int mcoords[][2],
+                                     short mcoords_len,
                                      const eSelectOp sel_op)
 {
   LassoSelectUserData data;
   rcti rect;
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
-  view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op);
+  view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
 
   if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
     data.is_changed |= ED_armature_edit_deselect_all_visible(vc->obedit);
@@ -1071,9 +1088,10 @@ static void do_lasso_select_mball__doSelectElem(void *userData,
 {
   LassoSelectUserData *data = userData;
   const bool is_select = ml->flag & SELECT;
-  const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
-                          BLI_lasso_is_point_inside(
-                              data->mcords, data->moves, screen_co[0], screen_co[1], INT_MAX));
+  const bool is_inside =
+      (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
+       BLI_lasso_is_point_inside(
+           data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], INT_MAX));
   const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
   if (sel_op_result != -1) {
     SET_FLAG_FROM_TEST(ml->flag, sel_op_result, SELECT);
@@ -1081,8 +1099,8 @@ static void do_lasso_select_mball__doSelectElem(void *userData,
   }
 }
 static bool do_lasso_select_meta(ViewContext *vc,
-                                 const int mcords[][2],
-                                 short moves,
+                                 const int mcoords[][2],
+                                 short mcoords_len,
                                  const eSelectOp sel_op)
 {
   LassoSelectUserData data;
@@ -1090,9 +1108,9 @@ static bool do_lasso_select_meta(ViewContext *vc,
 
   MetaBall *mb = (MetaBall *)vc->obedit->data;
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
-  view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op);
+  view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
 
   if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
     data.is_changed |= BKE_mball_deselect_all(mb);
@@ -1113,9 +1131,10 @@ static void do_lasso_select_meshobject__doSelectVert(void *userData,
 {
   LassoSelectUserData *data = userData;
   const bool is_select = mv->flag & SELECT;
-  const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
-                          BLI_lasso_is_point_inside(
-                              data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED));
+  const bool is_inside =
+      (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
+       BLI_lasso_is_point_inside(
+           data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED));
   const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
   if (sel_op_result != -1) {
     SET_FLAG_FROM_TEST(mv->flag, sel_op_result, SELECT);
@@ -1124,8 +1143,8 @@ static void do_lasso_select_meshobject__doSelectVert(void *userData,
 }
 static bool do_lasso_select_paintvert(ViewContext *vc,
                                       wmGenericUserData *wm_userdata,
-                                      const int mcords[][2],
-                                      short moves,
+                                      const int mcoords[][2],
+                                      short mcoords_len,
                                       const eSelectOp sel_op)
 {
   const bool use_zbuf = !XRAY_ENABLED(vc->v3d);
@@ -1143,7 +1162,7 @@ static bool do_lasso_select_paintvert(ViewContext *vc,
     changed |= paintvert_deselect_all_visible(ob, SEL_DESELECT, false);
   }
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
   struct EditSelectBuf_Cache *esel = wm_userdata->data;
   if (use_zbuf) {
@@ -1151,7 +1170,7 @@ static bool do_lasso_select_paintvert(ViewContext *vc,
       editselect_buf_cache_init_with_generic_userdata(wm_userdata, vc, SCE_SELECT_VERTEX);
       esel = wm_userdata->data;
       esel->select_bitmap = DRW_select_buffer_bitmap_from_poly(
-          vc->depsgraph, vc->region, vc->v3d, mcords, moves, &rect, NULL);
+          vc->depsgraph, vc->region, vc->v3d, mcoords, mcoords_len, &rect, NULL);
     }
   }
 
@@ -1163,7 +1182,7 @@ static bool do_lasso_select_paintvert(ViewContext *vc,
   else {
     LassoSelectUserData data;
 
-    view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op);
+    view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
 
     ED_view3d_init_mats_rv3d(vc->obact, vc->rv3d);
 
@@ -1185,8 +1204,8 @@ static bool do_lasso_select_paintvert(ViewContext *vc,
 }
 static bool do_lasso_select_paintface(ViewContext *vc,
                                       wmGenericUserData *wm_userdata,
-                                      const int mcords[][2],
-                                      short moves,
+                                      const int mcoords[][2],
+                                      short mcoords_len,
                                       const eSelectOp sel_op)
 {
   Object *ob = vc->obact;
@@ -1203,14 +1222,14 @@ static bool do_lasso_select_paintface(ViewContext *vc,
     changed |= paintface_deselect_all_visible(vc->C, ob, SEL_DESELECT, false);
   }
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
   struct EditSelectBuf_Cache *esel = wm_userdata->data;
   if (esel == NULL) {
     editselect_buf_cache_init_with_generic_userdata(wm_userdata, vc, SCE_SELECT_FACE);
     esel = wm_userdata->data;
     esel->select_bitmap = DRW_select_buffer_bitmap_from_poly(
-        vc->depsgraph, vc->region, vc->v3d, mcords, moves, &rect, NULL);
+        vc->depsgraph, vc->region, vc->v3d, mcoords, mcoords_len, &rect, NULL);
   }
 
   if (esel->select_bitmap) {
@@ -1224,7 +1243,7 @@ static bool do_lasso_select_paintface(ViewContext *vc,
 }
 
 #if 0
-static void do_lasso_select_node(int mcords[][2], short moves, const eSelectOp sel_op)
+static void do_lasso_select_node(int mcoords[][2], short mcoords_len, const eSelectOp sel_op)
 {
   SpaceNode *snode = area->spacedata.first;
 
@@ -1234,7 +1253,7 @@ static void do_lasso_select_node(int mcords[][2], short moves, const eSelectOp s
   float node_centf[2];
   bool changed = false;
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
   /* store selection in temp test flag */
   for (node = snode->edittree->nodes.first; node; node = node->next) {
@@ -1244,7 +1263,7 @@ static void do_lasso_select_node(int mcords[][2], short moves, const eSelectOp s
     ipoco_to_areaco_noclip(G.v2d, node_centf, node_cent);
     const bool is_select = node->flag & SELECT;
     const bool is_inside = (BLI_rcti_isect_pt_v(&rect, node_cent) &&
-                            BLI_lasso_is_point_inside(mcords, moves, node_cent[0], node_cent[1]));
+                            BLI_lasso_is_point_inside(mcoords, mcoords_len, node_cent[0], node_cent[1]));
     const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
     if (sel_op_result != -1) {
       SET_FLAG_FROM_TEST(node->flag, sel_op_result, SELECT);
@@ -1257,8 +1276,11 @@ static void do_lasso_select_node(int mcords[][2], short moves, const eSelectOp s
 }
 #endif
 
-static bool view3d_lasso_select(
-    bContext *C, ViewContext *vc, const int mcords[][2], short moves, const eSelectOp sel_op)
+static bool view3d_lasso_select(bContext *C,
+                                ViewContext *vc,
+                                const int mcoords[][2],
+                                short mcoords_len,
+                                const eSelectOp sel_op)
 {
   Object *ob = CTX_data_active_object(C);
   bool changed_multi = false;
@@ -1268,26 +1290,26 @@ static bool view3d_lasso_select(
 
   if (vc->obedit == NULL) { /* Object Mode */
     if (BKE_paint_select_face_test(ob)) {
-      changed_multi |= do_lasso_select_paintface(vc, wm_userdata, mcords, moves, sel_op);
+      changed_multi |= do_lasso_select_paintface(vc, wm_userdata, mcoords, mcoords_len, sel_op);
     }
     else if (BKE_paint_select_vert_test(ob)) {
-      changed_multi |= do_lasso_select_paintvert(vc, wm_userdata, mcords, moves, sel_op);
+      changed_multi |= do_lasso_select_paintvert(vc, wm_userdata, mcoords, mcoords_len, sel_op);
     }
     else if (ob &&
              (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT | OB_MODE_TEXTURE_PAINT))) {
       /* pass */
     }
     else if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT)) {
-      changed_multi |= PE_lasso_select(C, mcords, moves, sel_op);
+      changed_multi |= PE_lasso_select(C, mcoords, mcoords_len, sel_op);
     }
     else if (ob && (ob->mode & OB_MODE_POSE)) {
-      changed_multi |= do_lasso_select_pose(vc, mcords, moves, sel_op);
+      changed_multi |= do_lasso_select_pose(vc, mcoords, mcoords_len, sel_op);
       if (changed_multi) {
         ED_outliner_select_sync_from_pose_bone_tag(C);
       }
     }
     else {
-      changed_multi |= do_lasso_select_objects(vc, mcords, moves, sel_op);
+      changed_multi |= do_lasso_select_objects(vc, mcoords, mcoords_len, sel_op);
       if (changed_multi) {
         ED_outliner_select_sync_from_object_tag(C);
       }
@@ -1300,23 +1322,23 @@ static bool view3d_lasso_select(
 
       switch (vc->obedit->type) {
         case OB_MESH:
-          changed = do_lasso_select_mesh(vc, wm_userdata, mcords, moves, sel_op);
+          changed = do_lasso_select_mesh(vc, wm_userdata, mcoords, mcoords_len, sel_op);
           break;
         case OB_CURVE:
         case OB_SURF:
-          changed = do_lasso_select_curve(vc, mcords, moves, sel_op);
+          changed = do_lasso_select_curve(vc, mcoords, mcoords_len, sel_op);
           break;
         case OB_LATTICE:
-          changed = do_lasso_select_lattice(vc, mcords, moves, sel_op);
+          changed = do_lasso_select_lattice(vc, mcoords, mcoords_len, sel_op);
           break;
         case OB_ARMATURE:
-          changed = do_lasso_select_armature(vc, mcords, moves, sel_op);
+          changed = do_lasso_select_armature(vc, mcoords, mcoords_len, sel_op);
           if (changed) {
             ED_outliner_select_sync_from_edit_bone_tag(C);
           }
           break;
         case OB_MBALL:
-          changed = do_lasso_select_meta(vc, mcords, moves, sel_op);
+          changed = do_lasso_select_meta(vc, mcoords, mcoords_len, sel_op);
           break;
         default:
           BLI_assert(!"lasso select on incorrect object type");
@@ -1342,10 +1364,10 @@ static bool view3d_lasso_select(
 static int view3d_lasso_select_exec(bContext *C, wmOperator *op)
 {
   ViewContext vc;
-  int mcords_tot;
-  const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot);
+  int mcoords_len;
+  const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
 
-  if (mcords) {
+  if (mcoords) {
     Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
     view3d_operator_needs_opengl(C);
     BKE_object_update_select_id(CTX_data_main(C));
@@ -1354,9 +1376,9 @@ static int view3d_lasso_select_exec(bContext *C, wmOperator *op)
     ED_view3d_viewcontext_init(C, &vc, depsgraph);
 
     eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
-    bool changed_multi = view3d_lasso_select(C, &vc, mcords, mcords_tot, sel_op);
+    bool changed_multi = view3d_lasso_select(C, &vc, mcoords, mcoords_len, sel_op);
 
-    MEM_freeN((void *)mcords);
+    MEM_freeN((void *)mcoords);
 
     if (changed_multi) {
       return OPERATOR_FINISHED;
diff --git a/source/blender/editors/uvedit/uvedit_select.c b/source/blender/editors/uvedit/uvedit_select.c
index 6c184242e84..06866195c1c 100644
--- a/source/blender/editors/uvedit/uvedit_select.c
+++ b/source/blender/editors/uvedit/uvedit_select.c
@@ -2914,8 +2914,8 @@ static bool do_lasso_select_mesh_uv_is_point_inside(const ARegion *region,
 }
 
 static bool do_lasso_select_mesh_uv(bContext *C,
-                                    const int mcords[][2],
-                                    short moves,
+                                    const int mcoords[][2],
+                                    short mcoords_len,
                                     const eSelectOp sel_op)
 {
   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
@@ -2945,7 +2945,7 @@ static bool do_lasso_select_mesh_uv(bContext *C,
 
   uv_select_island_limit_default(sima, limit);
 
-  BLI_lasso_boundbox(&rect, mcords, moves);
+  BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
 
   uint objects_len = 0;
   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data_with_uvs(
@@ -2972,7 +2972,7 @@ static bool do_lasso_select_mesh_uv(bContext *C,
         if (select != uvedit_face_select_test(scene, efa, cd_loop_uv_offset)) {
           float cent[2];
           uv_poly_center(efa, cent, cd_loop_uv_offset);
-          if (do_lasso_select_mesh_uv_is_point_inside(region, &rect, mcords, moves, cent)) {
+          if (do_lasso_select_mesh_uv_is_point_inside(region, &rect, mcoords, mcoords_len, cent)) {
             BM_elem_flag_enable(efa, BM_ELEM_TAG);
             changed = true;
           }
@@ -3000,9 +3000,10 @@ static bool do_lasso_select_mesh_uv(bContext *C,
           MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
           const bool luv_select = uvedit_uv_select_test(scene, l, cd_loop_uv_offset);
           if ((select != luv_select) || (select != luv_select_prev)) {
-            if (do_lasso_select_mesh_uv_is_point_inside(region, &rect, mcords, moves, luv->uv) &&
+            if (do_lasso_select_mesh_uv_is_point_inside(
+                    region, &rect, mcoords, mcoords_len, luv->uv) &&
                 do_lasso_select_mesh_uv_is_point_inside(
-                    region, &rect, mcords, moves, luv_prev->uv)) {
+                    region, &rect, mcoords, mcoords_len, luv_prev->uv)) {
               uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
               uvedit_uv_select_set(em, scene, l_prev, select, false, cd_loop_uv_offset);
               changed = true;
@@ -3031,7 +3032,8 @@ static bool do_lasso_select_mesh_uv(bContext *C,
         BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
           if ((select) != (uvedit_uv_select_test(scene, l, cd_loop_uv_offset))) {
             MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
-            if (do_lasso_select_mesh_uv_is_point_inside(region, &rect, mcords, moves, luv->uv)) {
+            if (do_lasso_select_mesh_uv_is_point_inside(
+                    region, &rect, mcoords, mcoords_len, luv->uv)) {
               uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
               changed = true;
               BM_elem_flag_enable(l->v, BM_ELEM_TAG);
@@ -3068,13 +3070,13 @@ static bool do_lasso_select_mesh_uv(bContext *C,
 
 static int uv_lasso_select_exec(bContext *C, wmOperator *op)
 {
-  int mcords_tot;
-  const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot);
+  int mcoords_len;
+  const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
 
-  if (mcords) {
+  if (mcoords) {
     const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
-    bool changed = do_lasso_select_mesh_uv(C, mcords, mcords_tot, sel_op);
-    MEM_freeN((void *)mcords);
+    bool changed = do_lasso_select_mesh_uv(C, mcoords, mcoords_len, sel_op);
+    MEM_freeN((void *)mcoords);
 
     return changed ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
   }
diff --git a/source/blender/windowmanager/WM_api.h b/source/blender/windowmanager/WM_api.h
index 219060933f0..21a6088bfe9 100644
--- a/source/blender/windowmanager/WM_api.h
+++ b/source/blender/windowmanager/WM_api.h
@@ -617,7 +617,7 @@ int WM_gesture_lasso_modal(struct bContext *C, struct wmOperator *op, const stru
 void WM_gesture_lasso_cancel(struct bContext *C, struct wmOperator *op);
 const int (*WM_gesture_lasso_path_to_array(struct bContext *C,
                                            struct wmOperator *op,
-                                           int *mcords_tot))[2];
+                                           int *mcoords_len))[2];
 int WM_gesture_straightline_invoke(struct bContext *C,
                                    struct wmOperator *op,
                                    const struct wmEvent *event);
diff --git a/source/blender/windowmanager/intern/wm_gesture.c b/source/blender/windowmanager/intern/wm_gesture.c
index 71ae44297e7..9aa401722b7 100644
--- a/source/blender/windowmanager/intern/wm_gesture.c
+++ b/source/blender/windowmanager/intern/wm_gesture.c
@@ -320,24 +320,24 @@ static void draw_filled_lasso_px_cb(int x, int x_end, int y, void *user_data)
 static void draw_filled_lasso(wmGesture *gt)
 {
   const short *lasso = (short *)gt->customdata;
-  const int tot = gt->points;
-  int(*moves)[2] = MEM_mallocN(sizeof(*moves) * (tot + 1), __func__);
+  const int mcoords_len = gt->points;
+  int(*mcoords)[2] = MEM_mallocN(sizeof(*mcoords) * (mcoords_len + 1), __func__);
   int i;
   rcti rect;
   float red[4] = {1.0f, 0.0f, 0.0f, 0.0f};
 
-  for (i = 0; i < tot; i++, lasso += 2) {
-    moves[i][0] = lasso[0];
-    moves[i][1] = lasso[1];
+  for (i = 0; i < mcoords_len; i++, lasso += 2) {
+    mcoords[i][0] = lasso[0];
+    mcoords[i][1] = lasso[1];
   }
 
-  BLI_lasso_boundbox(&rect, (const int(*)[2])moves, tot);
+  BLI_lasso_boundbox(&rect, (const int(*)[2])mcoords, mcoords_len);
 
   BLI_rcti_translate(&rect, gt->winrct.xmin, gt->winrct.ymin);
   BLI_rcti_isect(&gt->winrct, &rect, &rect);
   BLI_rcti_translate(&rect, -gt->winrct.xmin, -gt->winrct.ymin);
 
-  /* highly unlikely this will fail, but could crash if (tot == 0) */
+  /* Highly unlikely this will fail, but could crash if (mcoords_len == 0). */
   if (BLI_rcti_is_empty(&rect) == false) {
     const int w = BLI_rcti_size_x(&rect);
     const int h = BLI_rcti_size_y(&rect);
@@ -348,8 +348,8 @@ static void draw_filled_lasso(wmGesture *gt)
                                   rect.ymin,
                                   rect.xmax,
                                   rect.ymax,
-                                  (const int(*)[2])moves,
-                                  tot,
+                                  (const int(*)[2])mcoords,
+                                  mcoords_len,
                                   draw_filled_lasso_px_cb,
                                   &lasso_fill_data);
 
@@ -390,7 +390,7 @@ static void draw_filled_lasso(wmGesture *gt)
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   }
 
-  MEM_freeN(moves);
+  MEM_freeN(mcoords);
 }
 
 static void wm_gesture_draw_lasso(wmGesture *gt, bool filled)
diff --git a/source/blender/windowmanager/intern/wm_gesture_ops.c b/source/blender/windowmanager/intern/wm_gesture_ops.c
index 11beb7d2fd5..9fb368a02b4 100644
--- a/source/blender/windowmanager/intern/wm_gesture_ops.c
+++ b/source/blender/windowmanager/intern/wm_gesture_ops.c
@@ -718,10 +718,10 @@ void WM_gesture_lines_cancel(bContext *C, wmOperator *op)
  */
 const int (*WM_gesture_lasso_path_to_array(bContext *UNUSED(C),
                                            wmOperator *op,
-                                           int *mcords_tot))[2]
+                                           int *r_mcoords_len))[2]
 {
   PropertyRNA *prop = RNA_struct_find_property(op->ptr, "path");
-  int(*mcords)[2] = NULL;
+  int(*mcoords)[2] = NULL;
   BLI_assert(prop != NULL);
 
   if (prop) {
@@ -729,26 +729,26 @@ const int (*WM_gesture_lasso_path_to_array(bContext *UNUSED(C),
 
     if (len) {
       int i = 0;
-      mcords = MEM_mallocN(sizeof(int) * 2 * len, __func__);
+      mcoords = MEM_mallocN(sizeof(int[2]) * len, __func__);
 
       RNA_PROP_BEGIN (op->ptr, itemptr, prop) {
         float loc[2];
 
         RNA_float_get_array(&itemptr, "loc", loc);
-        mcords[i][0] = (int)loc[0];
-        mcords[i][1] = (int)loc[1];
+        mcoords[i][0] = (int)loc[0];
+        mcoords[i][1] = (int)loc[1];
         i++;
       }
       RNA_PROP_END;
     }
-    *mcords_tot = len;
+    *r_mcoords_len = len;
   }
   else {
-    *mcords_tot = 0;
+    *r_mcoords_len = 0;
   }
 
   /* cast for 'const' */
-  return (const int(*)[2])mcords;
+  return mcoords;
 }
 
 #if 0