Add comments to build_stl_str_hl

src/nvim/buffer.c

@@ -2818,7 +2818,7 @@ void free_titles(void)
  * If maxwidth is not zero, the string will be filled at any middle marker
  * or truncated if too long, fillchar is used for all whitespace.
  */
-int 
+int
 build_stl_str_hl (
     win_T *wp,
     char_u *out,               /* buffer to write into != NameBuff */
@@ -2833,8 +2833,11 @@ build_stl_str_hl (
 {
   int groupitem[STL_MAX_ITEM];
   struct stl_item {
+    // Where the item starts in the status line output buffer
     char_u          *start;
+    // The minimum width of the item (at most 50 characters)
     int minwid;
+    // The maximum width of the item
     int maxwid;
     enum {
       Normal,
@@ -2846,6 +2849,13 @@ build_stl_str_hl (
       Trunc
     }               type;
   }           item[STL_MAX_ITEM];
+
+  enum number_base {
+     DECIMAL     = 10,
+     OCTAL       = 8,
+     HEXIDECIMAL = 16
+  };
+
 #define TMPLEN 70
   char_u tmp[TMPLEN];
   char_u      *usefmt = fmt;
@@ -2879,12 +2889,18 @@ build_stl_str_hl (
     byteval = (*mb_ptr2char)(line_ptr + wp->w_cursor.col);
 
   int groupdepth = 0;
-  char_u *p = out;
+
   int curitem = 0;
   bool prevchar_isflag = true;
   bool prevchar_isitem = false;
-  char_u *s;
+
-  for (s = usefmt; *s; ) {
+  // p is the current position in the output buffer
+  char_u *p = out;
+
+
+  // Proceed character by character through the statusline format string
+  // s is the current positon in the input buffer
+  for (char_u *s = usefmt; *s; ) {
     if (curitem == STL_MAX_ITEM) {
       /* There are too many items.  Add the error code to the statusline
        * to give the user a hint about what went wrong. */
@@ -2898,64 +2914,99 @@ build_stl_str_hl (
     if (*s != NUL && *s != '%')
       prevchar_isflag = prevchar_isitem = false;
 
-    /*
+    // Copy the formatting verbatim until we reach the end of the string
-     * Handle up to the next '%' or the end.
+    // or find a formatting item (denoted by `%`)
-     */
+    // or run out of room in our output buffer.
     while (*s != NUL && *s != '%' && p + 1 < out + outlen)
       *p++ = *s++;
+
+    // If we have processed the entire format string or run out of
+    // room in our output buffer, exit the loop.
     if (*s == NUL || p + 1 >= out + outlen)
       break;
 
-    /*
+    // The rest of this loop wil handle a single `%` item.
-     * Handle one '%' item.
+    // Note: We increment here to skip over the `%` character we are currently
-     */
+    //       on so we can process the item's contents.
     s++;
-    if (*s == NUL)      /* ignore trailing % */
+
+    // Ignore `%` at the end of the format string
+    if (*s == NUL) {
       break;
+    }
+
+    // Two `%` in a row is the escape sequence to print a
+    // single `%` in the output buffer.
     if (*s == '%') {
+      // Ignore the character if we're out of room in the output buffer.
       if (p + 1 >= out + outlen)
         break;
       *p++ = *s++;
       prevchar_isflag = prevchar_isitem = false;
       continue;
     }
+
+    // STL_MIDDLEMARK denotes the separation place between left and right aligned items.
     if (*s == STL_MIDDLEMARK) {
       s++;
-      if (groupdepth > 0)
+      // Ignored when we are inside of a grouping
+      if (groupdepth > 0) {
         continue;
+      }
       item[curitem].type = Middle;
       item[curitem++].start = p;
       continue;
     }
+
+    // STL_TRUNCMARK denotes where to begin truncating if the statusline is too long.
     if (*s == STL_TRUNCMARK) {
       s++;
       item[curitem].type = Trunc;
       item[curitem++].start = p;
       continue;
     }
+
+    // The end of a grouping
     if (*s == ')') {
       s++;
-      if (groupdepth < 1)
+      // Ignore if we are not actually inside a group currently
+      if (groupdepth < 1) {
         continue;
+      }
       groupdepth--;
 
+      //{ Determine how long the group is.
+      //  Note: We set the current output position to null so `vim_strsize` will work.
       char_u *t = item[groupitem[groupdepth]].start;
       *p = NUL;
       long l = vim_strsize(t);
+      //}
+
+      // If the group contained internal items and the group did not have a minimum width,
+      // and if there were no normal items in the group,
+      // move the output pointer back to where the group started (erase the group).
+      // Note: This also erases any plaintext characters that were in the group.
+      //       Otherwise there would be no reason to do this step.
       if (curitem > groupitem[groupdepth] + 1
           && item[groupitem[groupdepth]].minwid == 0) {
-        /* remove group if all items are empty */
+        bool has_normal_items = false;
-        long n;
+        for (long n = groupitem[groupdepth] + 1; n < curitem; n++) {
-        for (n = groupitem[groupdepth] + 1; n < curitem; n++)
+          if (item[n].type == Normal) {
-          if (item[n].type == Normal)
+            has_normal_items = true;
             break;
-        if (n == curitem) {
+          }
+        }
+
+        if (!has_normal_items) {
           p = t;
           l = 0;
         }
       }
+
+      // If the group is longer than it is allowed to be
+      // truncate by removing bytes from the start of the group text.
       if (l > item[groupitem[groupdepth]].maxwid) {
-        /* truncate, remove n bytes of text at the start */
+        //{ Determine the number of bytes to remove
         long n;
         if (has_mbyte) {
           /* Find the first character that should be included. */
@@ -2966,60 +3017,88 @@ build_stl_str_hl (
           }
         } else
           n = (long)(p - t) - item[groupitem[groupdepth]].maxwid + 1;
+        //}
 
+        // Prepend the `<` to indicate that the output was truncated.
         *t = '<';
+
+        //{ Move the truncated output
         memmove(t + 1, t + n, (size_t)(p - (t + n)));
         p = p - n + 1;
         /* Fill up space left over by half a double-wide char. */
         while (++l < item[groupitem[groupdepth]].minwid)
           *p++ = fillchar;
+        //}
 
         /* correct the start of the items for the truncation */
         for (l = groupitem[groupdepth] + 1; l < curitem; l++) {
+          // Shift everything back by the number of removed bytes
           item[l].start -= n;
+
+          // If the item was partially or completely truncated, set its
+          // start to the start of the group
           if (item[l].start < t)
             item[l].start = t;
         }
+      // If the group is shorter than the minimum width, add padding characters.
       } else if (abs(item[groupitem[groupdepth]].minwid) > l) {
-        /* fill */
+        long min_group_width = item[groupitem[groupdepth]].minwid;
-        long n = item[groupitem[groupdepth]].minwid;
+        // If the group is left-aligned, add characters to the right.
-        if (n < 0) {
+        if (min_group_width < 0) {
-          /* fill by appending characters */
+          min_group_width = 0 - min_group_width;
-          n = 0 - n;
+          while (l++ < min_group_width && p + 1 < out + outlen)
-          while (l++ < n && p + 1 < out + outlen)
             *p++ = fillchar;
+        // If the group is right-aligned, shift everything to the right and
+        // prepend with filler characters.
         } else {
-          /* fill by inserting characters */
+          //{ Move the group to the right
-          memmove(t + n - l, t, (size_t)(p - t));
+          memmove(t + min_group_width - l, t, (size_t)(p - t));
-          l = n - l;
+          l = min_group_width - l;
-          if (p + l >= out + outlen)
+          if (p + l >= out + outlen) {
             l = (long)((out + outlen) - p - 1);
+          }
           p += l;
-          for (n = groupitem[groupdepth] + 1; n < curitem; n++)
+          //}
+
+          // Adjust item start positions
+          for (int n = groupitem[groupdepth] + 1; n < curitem; n++) {
             item[n].start += l;
-          for (; l > 0; l--)
+          }
+
+          // Prepend the fill characters
+          for (; l > 0; l--) {
             *t++ = fillchar;
+          }
         }
       }
       continue;
     }
     int minwid = 0;
     int maxwid = 9999;
-    bool zeropad = false;
+    bool left_align = false;
-    long l = 1;
+
-    if (*s == '0') {
+    // Denotes that numbers should be left-padded with zeros
+    bool zeropad = (*s == '0');
+    if (zeropad) {
       s++;
-      zeropad = true;
     }
+
+    // Denotes that the item should be left-aligned.
+    // This is tracked by using a negative length.
     if (*s == '-') {
       s++;
-      l = -1;
+      left_align = true;
     }
+
+    // The first digit group is the item's min width
     if (ascii_isdigit(*s)) {
       minwid = getdigits_int(&s);
       if (minwid < 0)           /* overflow */
         minwid = 0;
     }
+
+    // User highlight groups override the min width field
+    // to denote the styling to use.
     if (*s == STL_USER_HL) {
       item[curitem].type = Highlight;
       item[curitem].start = p;
@@ -3049,6 +3128,9 @@ build_stl_str_hl (
       curitem++;
       continue;
     }
+
+    // Denotes the end of the minwid
+    // the maxwid may follow immediately after
     if (*s == '.') {
       s++;
       if (ascii_isdigit(*s)) {
@@ -3057,7 +3139,12 @@ build_stl_str_hl (
           maxwid = 50;
       }
     }
-    minwid = (minwid > 50 ? 50 : minwid) * l;
+
+    // Bound the minimum width at 50.
+    // Make the number negative to denote left alignment of the item
+    minwid = (minwid > 50 ? 50 : minwid) * (left_align ? -1 : 1);
+
+    // Denotes the start of a new group
     if (*s == '(') {
       groupitem[groupdepth++] = curitem;
       item[curitem].type = Group;
@@ -3068,14 +3155,19 @@ build_stl_str_hl (
       curitem++;
       continue;
     }
+
+    // An invalid item was specified.
+    // Continue processing on the next character of the format string.
     if (vim_strchr(STL_ALL, *s) == NULL) {
       s++;
       continue;
     }
+
+    // The status line item type
     char_u opt = *s++;
 
     /* OK - now for the real work */
-    char_u base = 'D';
+    enum number_base base = DECIMAL;
     bool itemisflag = false;
     bool fillable = true;
     long num = -1;
@@ -3103,6 +3195,9 @@ build_stl_str_hl (
     case STL_VIM_EXPR:     /* '{' */
     {
       itemisflag = true;
+
+      // Attempt to copy the expression to evaluate into
+      // the output buffer as a null-terminated string.
       char_u *t = p;
       while (*s != '}' && *s != NUL && p + 1 < out + outlen)
         *p++ = *s++;
@@ -3110,22 +3205,37 @@ build_stl_str_hl (
         break;
       s++;
       *p = 0;
+
+      // Move our position in the output buffer to the beginning of the expression
       p = t;
 
+      //{ Evaluate the expression
+
+      // Store the current buffer number as a string variable
       vim_snprintf((char *)tmp, sizeof(tmp), "%d", curbuf->b_fnum);
       set_internal_string_var((char_u *)"actual_curbuf", tmp);
 
+      // Switch the curbuf and curwin to the buffer and window we are evaluating the
+      // statusline for.
       buf_T *o_curbuf = curbuf;
       win_T *o_curwin = curwin;
       curwin = wp;
       curbuf = wp->w_buffer;
 
+      // Note: The result stored in `t` is unused.
       str = eval_to_string_safe(p, &t, use_sandbox);
 
+      // Switch back to the actual current buffer and window.
       curwin = o_curwin;
       curbuf = o_curbuf;
+
+      // Remove the variable we just stored
       do_unlet((char_u *)"g:actual_curbuf", TRUE);
 
+      //}
+
+      // Check if the evaluated result is a number.
+      // If so, convert the number to an int and free the string.
       if (str != NULL && *str != 0) {
         if (*skipdigits(str) == NUL) {
           num = atoi((char *)str);
@@ -3176,15 +3286,27 @@ build_stl_str_hl (
       break;
 
     case STL_ALTPERCENT:
+      // Store the position percentage in our temporary buffer.
+      // Note: We cannot store the value in `num` because
+      //       `get_rel_pos` can return a named position. Ex: "Top"
+      get_rel_pos(wp, tmp, TMPLEN);
       str = tmp;
-      get_rel_pos(wp, str, TMPLEN);
       break;
 
     case STL_ARGLISTSTAT:
       fillable = false;
+
+      // Note: This is important because `append_arg_number` starts appending
+      //       at the end of the null-terminated string.
+      //       Setting the first byte to null means it will place the argument
+      //       number string at the beginning of the buffer.
       tmp[0] = 0;
-      if (append_arg_number(wp, tmp, (int)sizeof(tmp), FALSE))
+
+      // Note: The call will only return true if it actually
+      //       appended data to the `tmp` buffer.
+      if (append_arg_number(wp, tmp, (int)sizeof(tmp), FALSE)) {
         str = tmp;
+      }
       break;
 
     case STL_KEYMAP:
@@ -3201,16 +3323,17 @@ build_stl_str_hl (
       break;
 
     case STL_OFFSET_X:
-      base = 'X';
+      base = HEXIDECIMAL;
     case STL_OFFSET:
-      l = ml_find_line_or_offset(wp->w_buffer, wp->w_cursor.lnum, NULL);
+    {
+      long l = ml_find_line_or_offset(wp->w_buffer, wp->w_cursor.lnum, NULL);
       num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) || l < 0 ?
             0L : l + 1 + (!(State & INSERT) && empty_line ?
                           0 : (int)wp->w_cursor.col);
       break;
-
+    }
     case STL_BYTEVAL_X:
-      base = 'X';
+      base = HEXIDECIMAL;
     case STL_BYTEVAL:
       num = byteval;
       if (num == NL)
@@ -3235,6 +3358,8 @@ build_stl_str_hl (
       break;
 
     case STL_FILETYPE:
+      // Copy the filetype if it is not null and the formatted string will fit
+      // in the temporary buffer (including the brackets and null terminating character)
       if (*wp->w_buffer->b_p_ft != NUL
           && STRLEN(wp->w_buffer->b_p_ft) < TMPLEN - 3) {
         vim_snprintf((char *)tmp, sizeof(tmp), "[%s]",
@@ -3246,12 +3371,16 @@ build_stl_str_hl (
     case STL_FILETYPE_ALT:
     {
       itemisflag = true;
+      // Copy the filetype if it is not null and the formatted string will fit
+      // in the temporary buffer (including the comma and null terminating character)
       if (*wp->w_buffer->b_p_ft != NUL
           && STRLEN(wp->w_buffer->b_p_ft) < TMPLEN - 2) {
         vim_snprintf((char *)tmp, sizeof(tmp), ",%s",
             wp->w_buffer->b_p_ft);
-        for (char_u *t = tmp; *t != 0; t++)
+        // Uppercase the file extension
+        for (char_u *t = tmp; *t != 0; t++) {
           *t = TOUPPER_LOC(*t);
+        }
         str = tmp;
       }
       break;
@@ -3288,24 +3417,35 @@ build_stl_str_hl (
 
     case STL_HIGHLIGHT:
     {
+      //{ The name of the highlight is surrounded by `#`
       char_u *t = s;
-      while (*s != '#' && *s != NUL)
+      while (*s != '#' && *s != NUL) {
         ++s;
+      }
+      //}
+
+      // Create a highlight item based on the name
       if (*s == '#') {
         item[curitem].type = Highlight;
         item[curitem].start = p;
         item[curitem].minwid = -syn_namen2id(t, (int)(s - t));
         curitem++;
+        s++;
       }
-      if (*s != NUL)
-        ++s;
       continue;
     }
     }
 
+    // If we made it this far, the item is normal and starts at
+    // our current position in the output buffer.
+    // Non-normal items would have `continued`.
     item[curitem].start = p;
     item[curitem].type = Normal;
+
+    // Copy the item string into the output buffer
     if (str != NULL && *str) {
+      //{ Skip the leading `,` or ` ` if the item is a flag
+      //  and the proper conditions are met
       char_u *t = str;
       if (itemisflag) {
         if ((t[0] && t[1])
@@ -3314,20 +3454,35 @@ build_stl_str_hl (
           t++;
         prevchar_isflag = true;
       }
-      l = vim_strsize(t);
+      //}
-      if (l > 0)
+
+      long l = vim_strsize(t);
+
+      // If this item is non-empty, record that the last thing
+      // we put in the output buffer was an item
+      if (l > 0) {
         prevchar_isitem = true;
+      }
+
+      // If the item is too wide, truncate it from the beginning
       if (l > maxwid) {
         while (l >= maxwid)
           if (has_mbyte) {
             l -= ptr2cells(t);
             t += (*mb_ptr2len)(t);
-          } else
+          } else {
             l -= byte2cells(*t++);
+          }
+
+        // Early out if there isn't enough room for the truncation marker
         if (p + 1 >= out + outlen)
           break;
+
+        // Add the truncation marker
         *p++ = '<';
       }
+
+      // If the item is right aligned and not wide enough, pad with fill characters.
       if (minwid > 0) {
         for (; l < minwid && p + 1 < out + outlen; l++) {
           /* Don't put a "-" in front of a digit. */
@@ -3337,8 +3492,13 @@ build_stl_str_hl (
             *p++ = fillchar;
         }
         minwid = 0;
-      } else
+      } else {
+        // Note: The negative value denotes a left aligned item.
+        //       Here we switch the minimum width back to a positive value.
         minwid *= -1;
+      }
+
+      //{ Copy the string text into the output buffer
       while (*t && p + 1 < out + outlen) {
         *p++ = *t++;
         /* Change a space by fillchar, unless fillchar is '-' and a
@@ -3347,150 +3507,255 @@ build_stl_str_hl (
             && (!ascii_isdigit(*t) || fillchar != '-'))
           p[-1] = fillchar;
       }
-      for (; l < minwid && p + 1 < out + outlen; l++)
+      //}
-        *p++ = fillchar;
-    } else if (num >= 0) {
-      int nbase = (base == 'D' ? 10 : (base == 'O' ? 8 : 16));
-      char_u nstr[20];
 
+      // For left-aligned items, fill any remaining space with the fillchar
+      for (; l < minwid && p + 1 < out + outlen; l++) {
+        *p++ = fillchar;
+      }
+
+    // Otherwise if the item is a number, copy that to the output buffer.
+    } else if (num >= 0) {
       if (p + 20 >= out + outlen)
         break;                  /* not sufficient space */
       prevchar_isitem = true;
+
+      //{ Build the formatting string
+      char_u nstr[20];
       char_u *t = nstr;
       if (opt == STL_VIRTCOL_ALT) {
         *t++ = '-';
         minwid--;
       }
       *t++ = '%';
-      if (zeropad)
+      if (zeropad) {
         *t++ = '0';
-      *t++ = '*';
+      }
-      *t++ = nbase == 16 ? base : (char_u)(nbase == 8 ? 'o' : 'd');
-      *t = 0;
 
-      long n;
+      // Note: The `*` means we take the width as one of the arguments
-      for (n = num, l = 1; n >= nbase; n /= nbase)
+      *t++ = '*';
+      *t++ = (char_u) (base == HEXIDECIMAL ? 'X' : (base == OCTAL ? 'o' : 'd'));
+      *t = 0;
+      //}
+
+      //{ Determine how many characters the number will take up when printed
+      long l;
+      for (long n = num, l = 1; n >= base; n /= base) {
         l++;
-      if (opt == STL_VIRTCOL_ALT)
+      }
+
+      // VIRTCOL_ALT takes up an extra character because of the `-` we added above.
+      if (opt == STL_VIRTCOL_ALT) {
         l++;
+      }
+      //}
+
+      size_t remaining_buf_len = (outlen - (p - out));
+
+      // If the number is going to take up too much room
+      // Figure out the approximate number in "scientific" type notation.
+      // Ex: 14532 with maxwid of 4 -> '14>3'
       if (l > maxwid) {
+        // Add two to the width because the power piece will take two extra characters
         l += 2;
-        n = l - maxwid;
+
-        while (l-- > maxwid)
+        // How many extra characters there are
-          num /= nbase;
+        long n = l - maxwid;
+
+        //{ Reduce the number by base^n
+        while (l-- > maxwid) {
+          num /= base;
+        }
+        //}
+
+        //{ Add the format string for the exponent bit
         *t++ = '>';
         *t++ = '%';
+        // Use the same base as the first number
         *t = t[-3];
         *++t = 0;
-        vim_snprintf((char *)p, outlen - (p - out), (char *)nstr,
+        //}
-            0, num, n);
-      } else
-        vim_snprintf((char *)p, outlen - (p - out), (char *)nstr,
-            minwid, num);
-      p += STRLEN(p);
-    } else
-      item[curitem].type = Empty;
 
-    if (opt == STL_VIM_EXPR)
+        vim_snprintf((char *)p, remaining_buf_len, (char *)nstr,
+            0, num, n);
+      } else {
+        vim_snprintf((char *)p, remaining_buf_len, (char *)nstr,
+            minwid, num);
+      }
+
+      // Advance the output buffer position to the end of the number we just printed
+      p += STRLEN(p);
+
+    // Otherwise, there was nothing to print so mark the item as empty
+    } else {
+      item[curitem].type = Empty;
+    }
+
+    // Free the string buffer if we allocated it.
+    // Note: This is not needed if `str` is pointing at `tmp`
+    if (opt == STL_VIM_EXPR) {
       xfree(str);
+    }
 
     if (num >= 0 || (!itemisflag && str && *str))
       prevchar_isflag = false;              /* Item not NULL, but not a flag */
+
+    // Item processed, move to the next
     curitem++;
   }
+
+  // Null terminate the output buffer
   *p = NUL;
   int itemcnt = curitem;
 
-  if (usefmt != fmt)
+  // Free the format buffer if we allocated it internally
+  if (usefmt != fmt) {
     xfree(usefmt);
+  }
 
   int width = vim_strsize(out);
   if (maxwidth > 0 && width > maxwidth) {
     /* Result is too long, must truncate somewhere. */
-    long l = 0;
+    int item_idx = 0;
-    if (itemcnt == 0)
+    char_u *trunc_p;
-      s = out;
+
-    else {
+    // If there are no items, truncate from beginning
-      for (; l < itemcnt; l++)
+    if (itemcnt == 0) {
-        if (item[l].type == Trunc) {
+      trunc_p = out;
-          /* Truncate at %< item. */
+
-          s = item[l].start;
+    // Otherwise, look for the truncation item
+    } else {
+      // Default to truncating at the first item
+      trunc_p = item[0].start;
+      item_idx = 0;
+
+      for (int i; i < itemcnt; i++)
+        if (item[i].type == Trunc) {
+          // Truncate at %< item.
+          trunc_p = item[i].start;
+          item_idx = i;
           break;
         }
-      if (l == itemcnt) {
-        /* No %< item, truncate first item. */
-        s = item[0].start;
-        l = 0;
-      }
     }
 
-    if (width - vim_strsize(s) >= maxwidth) {
+    // If the truncation point we found is beyond the maximum
-      /* Truncation mark is beyond max length */
+    // length of the string, truncate the end of the string.
+    if (width - vim_strsize(trunc_p) >= maxwidth) {
+      // If we are using a multi-byte encoding, walk from the beginning of the
+      // string to find the last character that will fit.
       if (has_mbyte) {
-        s = out;
+        trunc_p = out;
         width = 0;
         for (;; ) {
-          width += ptr2cells(s);
+          width += ptr2cells(trunc_p);
           if (width >= maxwidth)
             break;
-          s += (*mb_ptr2len)(s);
+
+          // Note: Only advance the pointer if the next
+          //       character will fit in the available output space
+          trunc_p += (*mb_ptr2len)(trunc_p);
         }
         /* Fill up for half a double-wide character. */
-        while (++width < maxwidth)
+        // XXX : This seems impossible given the exit condition above?
-          *s++ = fillchar;
+        while (++width < maxwidth) {
-      } else
+          *trunc_p++ = fillchar;
-        s = out + maxwidth - 1;
-      for (l = 0; l < itemcnt; l++)
-        if (item[l].start > s)
-          break;
-      itemcnt = l;
-      *s++ = '>';
-      *s = 0;
-    } else {
-      long n;
-      if (has_mbyte) {
-        n = 0;
-        while (width >= maxwidth) {
-          width -= ptr2cells(s + n);
-          n += (*mb_ptr2len)(s + n);
         }
-      } else
+
-        n = width - maxwidth + 1;
+      // Otherwise put the truncation point at the end, leaving enough room
-      p = s + n;
+      // for a single-character truncation marker
-      STRMOVE(s + 1, p);
+      } else {
-      *s = '<';
+        trunc_p = out + maxwidth - 1;
+      }
+
+      // Ignore any items in the statusline that occur after
+      // the truncation point
+      for (int i = 0; i < itemcnt; i++) {
+        if (item[i].start > trunc_p) {
+          itemcnt = i;
+          break;
+        }
+      }
+
+      // Truncate the output
+      *trunc_p++ = '>';
+      *trunc_p = 0;
+
+    // Truncate at the truncation point we found
+    } else {
+      //{ Determine how many bytes to remove
+      long trunc_len;
+      if (has_mbyte) {
+        trunc_len = 0;
+        while (width >= maxwidth) {
+          width     -= ptr2cells(trunc_p + trunc_len);
+          trunc_len += (*mb_ptr2len)(trunc_p + trunc_len);
+        }
+      } else {
+        // Truncate an extra character so we can insert our `<`.
+        trunc_len = (width - maxwidth) + 1;
+      }
+      //}
+
+      //{ Truncate the string
+      char_u *trunc_end_p = trunc_p + trunc_len;
+      STRMOVE(trunc_p + 1, trunc_end_p);
+
+      // Put a `<` to mark where we truncated at
+      *trunc_p = '<';
+
+      // Advance the pointer to the end of the string
+      trunc_p = trunc_p + STRLEN(trunc_p);
 
       /* Fill up for half a double-wide character. */
       while (++width < maxwidth) {
-        s = s + STRLEN(s);
+        *trunc_p++ = fillchar;
-        *s++ = fillchar;
+        *trunc_p = NUL;
-        *s = NUL;
       }
+      //}
 
-      --n;              /* count the '<' */
+      //{ Change the start point for items based on
-      for (; l < itemcnt; l++) {
+      //  their position relative to our truncation point
-        if (item[l].start - n >= s)
+
-          item[l].start -= n;
+      // Note: The offset is one less than the truncation length because
-        else
+      //       the truncation marker `<` is not counted.
-          item[l].start = s;
+      long item_offset = trunc_len - 1;
+
+      for (int i = item_idx; i < itemcnt; i++) {
+        // Items starting at or after the end of the truncated section need
+        // to be moved backwards.
+        if (item[i].start >= trunc_end_p) {
+          item[i].start -= item_offset;
+        // Anything inside the truncated area is set to start at the `<` truncation character.
+        } else {
+          item[i].start = trunc_p;
+        }
       }
+      //}
     }
     width = maxwidth;
-  } else if (width < maxwidth && STRLEN(out) + maxwidth - width + 1 <
-             outlen) {
-    /* Apply STL_MIDDLE if any */
-    for (long l = 0; l < itemcnt; l++)
-      if (item[l].type == Middle) {
-        p = item[l].start + maxwidth - width;
-        STRMOVE(p, item[l].start);
-        for (s = item[l].start; s < p; s++)
-          *s = fillchar;
-        for (l++; l < itemcnt; l++)
-          item[l].start += maxwidth - width;
-        width = maxwidth;
 
+  // If there is room left in our statusline, and room left in our buffer,
+  // add characters at the middle marker (if there is one) to fill up the available space.
+  } else if (width < maxwidth
+               && STRLEN(out) + maxwidth - width + 1 < outlen) {
+    for (int item_idx = 0; item_idx < itemcnt; item_idx++) {
+      if (item[item_idx].type == Middle) {
+        // Move the statusline to make room for the middle characters
+        char_u *middle_end = item[item_idx].start + (maxwidth - width);
+        STRMOVE(middle_end, item[item_idx].start);
+
+        // Fill the middle section with our fill character
+        for (char_u *s = item[item_idx].start; s < middle_end; s++)
+          *s = fillchar;
+
+        // Adjust the offset of any items after the middle
+        for (item_idx++; item_idx < itemcnt; item_idx++)
+          item[item_idx].start += maxwidth - width;
+
+        width = maxwidth;
         break;
       }
+    }
   }
 
   /* Store the info about highlighting. */