Cleanup: Use LISTBASE_FOREACH macro in curve code

These changes should result in more readable and undestandable code,
especially where while loops were use instead of for loops. They are
not comprehensive, and I skipped wherever the change was not obvious.

2 files changed, 53 insertions, 128 deletions

diff --git a/source/blender/blenkernel/intern/curve.c b/source/blender/blenkernel/intern/curve.c
index 1eb374d1a08..7e9ee1ad153 100644
--- a/source/blender/blenkernel/intern/curve.c
+++ b/source/blender/blenkernel/intern/curve.c
@@ -569,10 +569,9 @@ void BKE_curve_texspace_get(Curve *cu, float r_loc[3], float r_size[3])
 
 bool BKE_nurbList_index_get_co(ListBase *nurb, const int index, float r_co[3])
 {
-  Nurb *nu;
   int tot = 0;
 
-  for (nu = nurb->first; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, nurb) {
     int tot_nu;
     if (nu->type == CU_BEZIER) {
       tot_nu = nu->pntsu;
@@ -596,39 +595,33 @@ bool BKE_nurbList_index_get_co(ListBase *nurb, const int index, float r_co[3])
 
 int BKE_nurbList_verts_count(ListBase *nurb)
 {
-  Nurb *nu;
   int tot = 0;
 
-  nu = nurb->first;
-  while (nu) {
+  LISTBASE_FOREACH (Nurb *, nu, nurb) {
     if (nu->bezt) {
       tot += 3 * nu->pntsu;
     }
     else if (nu->bp) {
       tot += nu->pntsu * nu->pntsv;
     }
-
-    nu = nu->next;
   }
+
   return tot;
 }
 
 int BKE_nurbList_verts_count_without_handles(ListBase *nurb)
 {
-  Nurb *nu;
   int tot = 0;
 
-  nu = nurb->first;
-  while (nu) {
+  LISTBASE_FOREACH (Nurb *, nu, nurb) {
     if (nu->bezt) {
       tot += nu->pntsu;
     }
     else if (nu->bp) {
       tot += nu->pntsu * nu->pntsv;
     }
-
-    nu = nu->next;
   }
+
   return tot;
 }
 
@@ -636,7 +629,6 @@ int BKE_nurbList_verts_count_without_handles(ListBase *nurb)
 
 void BKE_nurb_free(Nurb *nu)
 {
-
   if (nu == NULL) {
     return;
   }
@@ -664,17 +656,12 @@ void BKE_nurb_free(Nurb *nu)
 
 void BKE_nurbList_free(ListBase *lb)
 {
-  Nurb *nu, *next;
-
   if (lb == NULL) {
     return;
   }
 
-  nu = lb->first;
-  while (nu) {
-    next = nu->next;
+  LISTBASE_FOREACH_MUTABLE (Nurb *, nu, lb) {
     BKE_nurb_free(nu);
-    nu = next;
   }
   BLI_listbase_clear(lb);
 }
@@ -747,16 +734,11 @@ Nurb *BKE_nurb_copy(Nurb *src, int pntsu, int pntsv)
 
 void BKE_nurbList_duplicate(ListBase *lb1, const ListBase *lb2)
 {
-  Nurb *nu, *nun;
-
   BKE_nurbList_free(lb1);
 
-  nu = lb2->first;
-  while (nu) {
-    nun = BKE_nurb_duplicate(nu);
-    BLI_addtail(lb1, nun);
-
-    nu = nu->next;
+  LISTBASE_FOREACH (const Nurb *, nu, lb2) {
+    Nurb *nurb_new = BKE_nurb_duplicate(nu);
+    BLI_addtail(lb1, nurb_new);
   }
 }
 
@@ -2625,9 +2607,7 @@ static void bevlist_firstlast_direction_calc_from_bpoint(Nurb *nu, BevList *bl)
 
 void BKE_curve_bevelList_free(ListBase *bev)
 {
-  BevList *bl, *blnext;
-  for (bl = bev->first; bl != NULL; bl = blnext) {
-    blnext = bl->next;
+  LISTBASE_FOREACH_MUTABLE (BevList *, bl, bev) {
     if (bl->seglen != NULL) {
       MEM_freeN(bl->seglen);
     }
@@ -2654,10 +2634,9 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
 
   /* this function needs an object, because of tflag and upflag */
   Curve *cu = ob->data;
-  Nurb *nu;
   BezTriple *bezt, *prevbezt;
   BPoint *bp;
-  BevList *bl, *blnew, *blnext;
+  BevList *blnew;
   BevPoint *bevp2, *bevp1 = NULL, *bevp0;
   const float treshold = 0.00001f;
   float min, inp;
@@ -2685,12 +2664,11 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
   /* STEP 1: MAKE POLYS  */
 
   BKE_curve_bevelList_free(&ob->runtime.curve_cache->bev);
-  nu = nurbs->first;
   if (cu->editnurb && ob->type != OB_FONT) {
     is_editmode = 1;
   }
 
-  for (; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, nurbs) {
     if (nu->hide && is_editmode) {
       continue;
     }
@@ -2706,7 +2684,7 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
     /* check we are a single point? also check we are not a surface and that the orderu is sane,
      * enforced in the UI but can go wrong possibly */
     if (!BKE_nurb_check_valid_u(nu)) {
-      bl = MEM_callocN(sizeof(BevList), "makeBevelList1");
+      BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelList1");
       bl->bevpoints = MEM_calloc_arrayN(1, sizeof(BevPoint), "makeBevelPoints1");
       BLI_addtail(bev, bl);
       bl->nr = 0;
@@ -2726,7 +2704,7 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
 
       if (nu->type == CU_POLY) {
         len = nu->pntsu;
-        bl = MEM_callocN(sizeof(BevList), "makeBevelList2");
+        BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelList2");
         bl->bevpoints = MEM_calloc_arrayN(len, sizeof(BevPoint), "makeBevelPoints2");
         if (need_seglen && (nu->flagu & CU_NURB_CYCLIC) == 0) {
           bl->seglen = MEM_malloc_arrayN(segcount, sizeof(float), "makeBevelList2_seglen");
@@ -2777,7 +2755,7 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
         /* in case last point is not cyclic */
         len = segcount * resolu + 1;
 
-        bl = MEM_callocN(sizeof(BevList), "makeBevelBPoints");
+        BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelBPoints");
         bl->bevpoints = MEM_calloc_arrayN(len, sizeof(BevPoint), "makeBevelBPointsPoints");
         if (need_seglen && (nu->flagu & CU_NURB_CYCLIC) == 0) {
           bl->seglen = MEM_malloc_arrayN(segcount, sizeof(float), "makeBevelBPoints_seglen");
@@ -2930,7 +2908,7 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
         if (nu->pntsv == 1) {
           len = (resolu * segcount);
 
-          bl = MEM_callocN(sizeof(BevList), "makeBevelList3");
+          BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelList3");
           bl->bevpoints = MEM_calloc_arrayN(len, sizeof(BevPoint), "makeBevelPoints3");
           if (need_seglen && (nu->flagu & CU_NURB_CYCLIC) == 0) {
             bl->seglen = MEM_malloc_arrayN(segcount, sizeof(float), "makeBevelList3_seglen");
@@ -2989,8 +2967,7 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
   }
 
   /* STEP 2: DOUBLE POINTS AND AUTOMATIC RESOLUTION, REDUCE DATABLOCKS */
-  bl = bev->first;
-  while (bl) {
+  LISTBASE_FOREACH (BevList *, bl, bev) {
     if (bl->nr) { /* null bevel items come from single points */
       bool is_cyclic = bl->poly != -1;
       nr = bl->nr;
@@ -3025,11 +3002,9 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
         bevp1++;
       }
     }
-    bl = bl->next;
   }
-  bl = bev->first;
-  while (bl) {
-    blnext = bl->next;
+
+  LISTBASE_FOREACH_MUTABLE (BevList *, bl, bev) {
     if (bl->nr && bl->dupe_nr) {
       nr = bl->nr - bl->dupe_nr + 1; /* +1 because vectorbezier sets flag too */
       blnew = MEM_mallocN(sizeof(BevList), "makeBevelList4");
@@ -3043,7 +3018,7 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
       blnew->seglen = bl->seglen;
       blnew->nr = 0;
       BLI_remlink(bev, bl);
-      BLI_insertlinkbefore(bev, blnext, blnew); /* to make sure bevlijst is tuned with nurblist */
+      BLI_insertlinkbefore(bev, bl->next, blnew); /* to make sure bevlist is tuned with nurblist */
       bevp0 = bl->bevpoints;
       bevp1 = blnew->bevpoints;
       nr = bl->nr;
@@ -3061,26 +3036,22 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
       MEM_freeN(bl);
       blnew->dupe_nr = 0;
     }
-    bl = blnext;
   }
 
   /* STEP 3: POLYS COUNT AND AUTOHOLE */
-  bl = bev->first;
   poly = 0;
-  while (bl) {
+  LISTBASE_FOREACH (BevList *, bl, bev) {
     if (bl->nr && bl->poly >= 0) {
       poly++;
       bl->poly = poly;
       bl->hole = 0;
     }
-    bl = bl->next;
   }
 
   /* find extreme left points, also test (turning) direction */
   if (poly > 0) {
     sd = sortdata = MEM_malloc_arrayN(poly, sizeof(struct BevelSort), "makeBevelList5");
-    bl = bev->first;
-    while (bl) {
+    LISTBASE_FOREACH (BevList *, bl, bev) {
       if (bl->poly > 0) {
         BevPoint *bevp;
 
@@ -3125,14 +3096,12 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
 
         sd++;
       }
-
-      bl = bl->next;
     }
     qsort(sortdata, poly, sizeof(struct BevelSort), vergxcobev);
 
     sd = sortdata + 1;
     for (a = 1; a < poly; a++, sd++) {
-      bl = sd->bl; /* is bl a hole? */
+      BevList *bl = sd->bl; /* is bl a hole? */
       sd1 = sortdata + (a - 1);
       for (b = a - 1; b >= 0; b--, sd1--) {    /* all polys to the left */
         if (sd1->bl->charidx == bl->charidx) { /* for text, only check matching char */
@@ -3149,7 +3118,7 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
       sd = sortdata;
       for (a = 0; a < poly; a++, sd++) {
         if (sd->bl->hole == sd->dir) {
-          bl = sd->bl;
+          BevList *bl = sd->bl;
           bevp1 = bl->bevpoints;
           bevp2 = bevp1 + (bl->nr - 1);
           nr = bl->nr / 2;
@@ -3167,7 +3136,7 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
   /* STEP 4: 2D-COSINES or 3D ORIENTATION */
   if ((cu->flag & CU_3D) == 0) {
     /* 2D Curves */
-    for (bl = bev->first; bl; bl = bl->next) {
+    LISTBASE_FOREACH (BevList *, bl, bev) {
       if (bl->nr < 2) {
         BevPoint *bevp = bl->bevpoints;
         unit_qt(bevp->quat);
@@ -3182,7 +3151,7 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
   }
   else {
     /* 3D Curves */
-    for (bl = bev->first; bl; bl = bl->next) {
+    LISTBASE_FOREACH (BevList *, bl, bev) {
       if (bl->nr < 2) {
         BevPoint *bevp = bl->bevpoints;
         unit_qt(bevp->quat);
@@ -4316,12 +4285,8 @@ void BKE_nurb_handles_autocalc(Nurb *nu, uint8_t flag)
 
 void BKE_nurbList_handles_autocalc(ListBase *editnurb, uint8_t flag)
 {
-  Nurb *nu;
-
-  nu = editnurb->first;
-  while (nu) {
+  LISTBASE_FOREACH (Nurb *, nu, editnurb) {
     BKE_nurb_handles_autocalc(nu, flag);
-    nu = nu->next;
   }
 }
 
@@ -4333,13 +4298,11 @@ void BKE_nurbList_handles_set(ListBase *editnurb, const char code)
   /* code==4: sets icu flag to become IPO_AUTO_HORIZ, horizontal extremes on auto-handles */
   /* code==5: Set align, like 3 but no toggle */
   /* code==6: Clear align, like 3 but no toggle */
-  Nurb *nu;
   BezTriple *bezt;
   int a;
 
   if (ELEM(code, HD_AUTO, HD_VECT)) {
-    nu = editnurb->first;
-    while (nu) {
+    LISTBASE_FOREACH (Nurb *, nu, editnurb) {
       if (nu->type == CU_BEZIER) {
         bezt = nu->bezt;
         a = nu->pntsu;
@@ -4366,7 +4329,6 @@ void BKE_nurbList_handles_set(ListBase *editnurb, const char code)
         /* like BKE_nurb_handles_calc but moves selected */
         nurb_handles_calc__align_selected(nu);
       }
-      nu = nu->next;
     }
   }
   else {
@@ -4381,7 +4343,7 @@ void BKE_nurbList_handles_set(ListBase *editnurb, const char code)
     }
     else {
       /* Toggle */
-      for (nu = editnurb->first; nu; nu = nu->next) {
+      LISTBASE_FOREACH (Nurb *, nu, editnurb) {
         if (nu->type == CU_BEZIER) {
           bezt = nu->bezt;
           a = nu->pntsu;
@@ -4397,7 +4359,7 @@ void BKE_nurbList_handles_set(ListBase *editnurb, const char code)
       }
       h_new = (h_new == HD_FREE) ? HD_ALIGN : HD_FREE;
     }
-    for (nu = editnurb->first; nu; nu = nu->next) {
+    LISTBASE_FOREACH (Nurb *, nu, editnurb) {
       if (nu->type == CU_BEZIER) {
         bezt = nu->bezt;
         a = nu->pntsu;
@@ -4423,11 +4385,10 @@ void BKE_nurbList_handles_recalculate(ListBase *editnurb,
                                       const bool calc_length,
                                       const uint8_t flag)
 {
-  Nurb *nu;
   BezTriple *bezt;
   int a;
 
-  for (nu = editnurb->first; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, editnurb) {
     if (nu->type == CU_BEZIER) {
       bool changed = false;
 
@@ -4477,12 +4438,11 @@ void BKE_nurbList_handles_recalculate(ListBase *editnurb,
 
 void BKE_nurbList_flag_set(ListBase *editnurb, uint8_t flag, bool set)
 {
-  Nurb *nu;
   BezTriple *bezt;
   BPoint *bp;
   int a;
 
-  for (nu = editnurb->first; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, editnurb) {
     if (nu->type == CU_BEZIER) {
       a = nu->pntsu;
       bezt = nu->bezt;
@@ -4518,7 +4478,7 @@ bool BKE_nurbList_flag_set_from_flag(ListBase *editnurb, uint8_t from_flag, uint
 {
   bool changed = false;
 
-  for (Nurb *nu = editnurb->first; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, editnurb) {
     if (nu->type == CU_BEZIER) {
       for (int i = 0; i < nu->pntsu; i++) {
         BezTriple *bezt = &nu->bezt[i];
@@ -5232,12 +5192,11 @@ bool BKE_curve_minmax(Curve *cu, bool use_radius, float min[3], float max[3])
 bool BKE_curve_center_median(Curve *cu, float cent[3])
 {
   ListBase *nurb_lb = BKE_curve_nurbs_get(cu);
-  Nurb *nu;
   int total = 0;
 
   zero_v3(cent);
 
-  for (nu = nurb_lb->first; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, nurb_lb) {
     int i;
 
     if (nu->type == CU_BEZIER) {
@@ -5285,12 +5244,11 @@ void BKE_curve_transform_ex(Curve *cu,
                             const bool do_props,
                             const float unit_scale)
 {
-  Nurb *nu;
   BPoint *bp;
   BezTriple *bezt;
   int i;
 
-  for (nu = cu->nurb.first; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
     if (nu->type == CU_BEZIER) {
       i = nu->pntsu;
       for (bezt = nu->bezt; i--; bezt++) {
@@ -5320,7 +5278,7 @@ void BKE_curve_transform_ex(Curve *cu,
       float *fp = kb->data;
       int n = kb->totelem;
 
-      for (nu = cu->nurb.first; nu; nu = nu->next) {
+      LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
         if (nu->type == CU_BEZIER) {
           for (i = nu->pntsu; i && (n -= KEYELEM_ELEM_LEN_BEZTRIPLE) >= 0; i--) {
             mul_m4_v3(mat, &fp[0]);
diff --git a/source/blender/blenkernel/intern/displist.c b/source/blender/blenkernel/intern/displist.c
index bcb467e1230..f47f350a435 100644
--- a/source/blender/blenkernel/intern/displist.c
+++ b/source/blender/blenkernel/intern/displist.c
@@ -92,17 +92,13 @@ void BKE_displist_free(ListBase *lb)
 
 DispList *BKE_displist_find_or_create(ListBase *lb, int type)
 {
-  DispList *dl;
-
-  dl = lb->first;
-  while (dl) {
+  LISTBASE_FOREACH (DispList *, dl, lb) {
     if (dl->type == type) {
       return dl;
     }
-    dl = dl->next;
   }
 
-  dl = MEM_callocN(sizeof(DispList), "find_disp");
+  DispList *dl = MEM_callocN(sizeof(DispList), "find_disp");
   dl->type = type;
   BLI_addtail(lb, dl);
 
@@ -111,14 +107,10 @@ DispList *BKE_displist_find_or_create(ListBase *lb, int type)
 
 DispList *BKE_displist_find(ListBase *lb, int type)
 {
-  DispList *dl;
-
-  dl = lb->first;
-  while (dl) {
+  LISTBASE_FOREACH (DispList *, dl, lb) {
     if (dl->type == type) {
       return dl;
     }
-    dl = dl->next;
   }
 
   return NULL;
@@ -126,9 +118,7 @@ DispList *BKE_displist_find(ListBase *lb, int type)
 
 bool BKE_displist_has_faces(ListBase *lb)
 {
-  DispList *dl;
-
-  for (dl = lb->first; dl; dl = dl->next) {
+  LISTBASE_FOREACH (DispList *, dl, lb) {
     if (ELEM(dl->type, DL_INDEX3, DL_INDEX4, DL_SURF)) {
       return true;
     }
@@ -139,13 +129,10 @@ bool BKE_displist_has_faces(ListBase *lb)
 
 void BKE_displist_copy(ListBase *lbn, ListBase *lb)
 {
-  DispList *dln, *dl;
-
   BKE_displist_free(lbn);
 
-  dl = lb->first;
-  while (dl) {
-    dln = MEM_dupallocN(dl);
+  LISTBASE_FOREACH (const DispList *, dl, lb) {
+    DispList *dln = MEM_dupallocN(dl);
     BLI_addtail(lbn, dln);
     dln->verts = MEM_dupallocN(dl->verts);
     dln->nors = MEM_dupallocN(dl->nors);
@@ -154,22 +141,18 @@ void BKE_displist_copy(ListBase *lbn, ListBase *lb)
     if (dl->bevel_split) {
       dln->bevel_split = MEM_dupallocN(dl->bevel_split);
     }
-
-    dl = dl->next;
   }
 }
 
 void BKE_displist_normals_add(ListBase *lb)
 {
-  DispList *dl = NULL;
   float *vdata, *ndata, nor[3];
   float *v1, *v2, *v3, *v4;
   float *n1, *n2, *n3, *n4;
   int a, b, p1, p2, p3, p4;
 
-  dl = lb->first;
+  LISTBASE_FOREACH (DispList *, dl, lb) {
 
-  while (dl) {
     if (dl->type == DL_INDEX3) {
       if (dl->nors == NULL) {
         dl->nors = MEM_callocN(sizeof(float[3]), "dlnors");
@@ -230,15 +213,12 @@ void BKE_displist_normals_add(ListBase *lb)
         }
       }
     }
-    dl = dl->next;
   }
 }
 
 void BKE_displist_count(ListBase *lb, int *totvert, int *totface, int *tottri)
 {
-  DispList *dl;
-
-  for (dl = lb->first; dl; dl = dl->next) {
+  LISTBASE_FOREACH (DispList *, dl, lb) {
     int vert_tot = 0;
     int face_tot = 0;
     int tri_tot = 0;
@@ -318,7 +298,6 @@ static void curve_to_displist(Curve *cu,
                               ListBase *dispbase,
                               const bool for_render)
 {
-  Nurb *nu;
   DispList *dl;
   BezTriple *bezt, *prevbezt;
   BPoint *bp;
@@ -326,8 +305,7 @@ static void curve_to_displist(Curve *cu,
   int a, len, resolu;
   const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
 
-  nu = nubase->first;
-  while (nu) {
+  LISTBASE_FOREACH (Nurb *, nu, nubase) {
     if (nu->hide == 0 || editmode == false) {
       if (for_render && cu->resolu_ren != 0) {
         resolu = cu->resolu_ren;
@@ -473,7 +451,6 @@ static void curve_to_displist(Curve *cu,
         }
       }
     }
-    nu = nu->next;
   }
 }
 
@@ -627,19 +604,14 @@ static void bevels_to_filledpoly(Curve *cu, ListBase *dispbase)
 {
   const float z_up[3] = {0.0f, 0.0f, -1.0f};
   ListBase front, back;
-  DispList *dl, *dlnew;
   float *fp, *fp1;
   int a, dpoly;
 
-  BLI_listbase_clear(&front);
-  BLI_listbase_clear(&back);
-
-  dl = dispbase->first;
-  while (dl) {
+  LISTBASE_FOREACH (DispList *, dl, dispbase) {
     if (dl->type == DL_SURF) {
       if ((dl->flag & DL_CYCL_V) && (dl->flag & DL_CYCL_U) == 0) {
         if ((cu->flag & CU_BACK) && (dl->flag & DL_BACK_CURVE)) {
-          dlnew = MEM_callocN(sizeof(DispList), "filldisp");
+          DispList *dlnew = MEM_callocN(sizeof(DispList), "filldisp");
           BLI_addtail(&front, dlnew);
           dlnew->verts = fp1 = MEM_mallocN(sizeof(float[3]) * dl->parts, "filldisp1");
           dlnew->nr = dl->parts;
@@ -660,7 +632,7 @@ static void bevels_to_filledpoly(Curve *cu, ListBase *dispbase)
           }
         }
         if ((cu->flag & CU_FRONT) && (dl->flag & DL_FRONT_CURVE)) {
-          dlnew = MEM_callocN(sizeof(DispList), "filldisp");
+          DispList *dlnew = MEM_callocN(sizeof(DispList), "filldisp");
           BLI_addtail(&back, dlnew);
           dlnew->verts = fp1 = MEM_mallocN(sizeof(float[3]) * dl->parts, "filldisp1");
           dlnew->nr = dl->parts;
@@ -682,7 +654,6 @@ static void bevels_to_filledpoly(Curve *cu, ListBase *dispbase)
         }
       }
     }
-    dl = dl->next;
   }
 
   BKE_displist_fill(&front, dispbase, z_up, true);
@@ -939,18 +910,17 @@ static bool curve_calc_modifiers_pre(
 
 static float (*displist_vert_coords_alloc(ListBase *dispbase, int *r_vert_len))[3]
 {
-  DispList *dl;
   float(*allverts)[3], *fp;
 
   *r_vert_len = 0;
 
-  for (dl = dispbase->first; dl; dl = dl->next) {
+  LISTBASE_FOREACH (DispList *, dl, dispbase) {
     *r_vert_len += (dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr;
   }
 
   allverts = MEM_mallocN(sizeof(float[3]) * (*r_vert_len), "displist_vert_coords_alloc allverts");
   fp = (float *)allverts;
-  for (dl = dispbase->first; dl; dl = dl->next) {
+  LISTBASE_FOREACH (DispList *, dl, dispbase) {
     int offs = 3 * ((dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr);
     memcpy(fp, dl->verts, sizeof(float) * offs);
     fp += offs;
@@ -961,11 +931,10 @@ static float (*displist_vert_coords_alloc(ListBase *dispbase, int *r_vert_len))[
 
 static void displist_vert_coords_apply(ListBase *dispbase, float (*allverts)[3])
 {
-  DispList *dl;
   const float *fp;
 
   fp = (float *)allverts;
-  for (dl = dispbase->first; dl; dl = dl->next) {
+  LISTBASE_FOREACH (DispList *, dl, dispbase) {
     int offs = 3 * ((dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr);
     memcpy(dl->verts, fp, sizeof(float) * offs);
     fp += offs;
@@ -1218,7 +1187,6 @@ void BKE_displist_make_surf(Depsgraph *depsgraph,
                             const bool for_orco)
 {
   ListBase nubase = {NULL, NULL};
-  Nurb *nu;
   Curve *cu = ob->data;
   DispList *dl;
   float *data;
@@ -1236,7 +1204,7 @@ void BKE_displist_make_surf(Depsgraph *depsgraph,
     force_mesh_conversion = curve_calc_modifiers_pre(depsgraph, scene, ob, &nubase, for_render);
   }
 
-  for (nu = nubase.first; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, &nubase) {
     if ((for_render || nu->hide == 0) && BKE_nurb_check_valid_uv(nu)) {
       int resolu = nu->resolu, resolv = nu->resolv;
 
@@ -1851,12 +1819,11 @@ void BKE_displist_make_curveTypes_forRender(Depsgraph *depsgraph,
 
 void BKE_displist_minmax(ListBase *dispbase, float min[3], float max[3])
 {
-  DispList *dl;
   const float *vert;
   int a, tot = 0;
   int doit = 0;
 
-  for (dl = dispbase->first; dl; dl = dl->next) {
+  LISTBASE_FOREACH (DispList *, dl, dispbase) {
     tot = (dl->type == DL_INDEX3) ? dl->nr : dl->nr * dl->parts;
     vert = dl->verts;
     for (a = 0; a < tot; a++, vert += 3) {