Shorten CWD path

For showing the CWD path in a more compact way, this function

    - shortens path parts before last from right to left, until first
      character of the path stays (directory -> direc~ or d~)
    - combines parts before last from right with left (a~/b~ -> a~~)
    - shortens the last part from middle, preferring to keep characters
      from left (longdirectoryname -> long~ame)

in order (of 2nd and 3rd, the one that removes more characters is
applied first) until given maximum length is reached.

Author: Ekin Dursun

CwdUtils.c

@@ -0,0 +1,153 @@
+#include "CwdUtils.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <wchar.h>
+
+#include "XUtils.h"
+
+typedef struct ShortenCwdContext {
+   size_t maxLength;
+   size_t len;
+   wchar_t **parts;
+   size_t partsLen;
+   size_t *partLengths;
+} ShortenCwdContext;
+
+static void shortenCwdParts(ShortenCwdContext *ctx) {
+   for (int i = ctx->partsLen - 2; i >= 0 && ctx->len > ctx->maxLength; i--) {
+      if (ctx->partLengths[i] < 3)
+         continue;
+
+      size_t extraChars = ctx->len - ctx->maxLength;
+      size_t maxRemovableChars = ctx->partLengths[i] - 2;
+      size_t charsToRemove = extraChars < maxRemovableChars ? extraChars : maxRemovableChars;
+
+      ctx->partLengths[i] -= charsToRemove;
+      ctx->len -= charsToRemove;
+
+      Wstring_safeWcsncpy(ctx->parts[i] + (ctx->partLengths[i] - 1), L"~", 2);
+   }
+}
+
+static size_t collapseCwdParts(ShortenCwdContext *ctx, bool doActualWork) {
+   if (ctx->len <= ctx->maxLength || ctx->partsLen <= 3)
+      return 0;
+
+   size_t len = ctx->len;
+
+   size_t i;
+   for (i = ctx->partsLen - 2; i > 1; i--) {
+      if (len + (3 - ctx->partLengths[i]) <= ctx->maxLength)
+         break;
+
+      len -= ctx->partLengths[i] + 1;
+
+      if (doActualWork) {
+         ctx->partLengths[i] = 0;
+         free(ctx->parts[i]);
+         ctx->parts[i] = NULL;
+      }
+   }
+
+   len += 3 - ctx->partLengths[i];
+   size_t diff = ctx->len - len;
+
+   if (doActualWork) {
+      wchar_t newPart[] = L"~~~";
+      newPart[0] = ctx->parts[i][0];
+      free(ctx->parts[i]);
+      ctx->parts[i] = xWcsdup(newPart);
+      ctx->partLengths[i] = 3;
+      ctx->len = len;
+   }
+
+   return diff;
+}
+
+static size_t shortenCwdLastPart(ShortenCwdContext *ctx, bool doActualWork) {
+   if (ctx->len <= ctx->maxLength)
+      return 0;
+
+   size_t lastPartLen = ctx->partLengths[ctx->partsLen - 1];
+   if (lastPartLen <= 3)
+      return 0;
+
+   wchar_t *lastPart = ctx->parts[ctx->partsLen - 1];
+   size_t extraChars = ctx->len - ctx->maxLength + 1;
+   size_t maxRemovableChars = lastPartLen - 2;
+   size_t charsToRemove = extraChars < maxRemovableChars ? extraChars : maxRemovableChars;
+
+   if (doActualWork) {
+      size_t charsAtBeginning = (lastPartLen - charsToRemove + 1) / 2;
+      size_t charsAtEnd = lastPartLen - charsToRemove - charsAtBeginning;
+      lastPart[charsAtBeginning] = '~';
+      wmemmove(lastPart + charsAtBeginning + 1, lastPart + lastPartLen - charsAtEnd, charsAtEnd);
+      lastPart[charsAtBeginning + charsAtEnd + 1] = '\0';
+      ctx->partLengths[ctx->partsLen - 1] = lastPartLen - charsToRemove + 1;
+      ctx->len -= charsToRemove - 1;
+   }
+
+   return charsToRemove - 1;
+}
+
+static wchar_t* buildCwdFromParts(ShortenCwdContext *ctx) {
+   size_t len = ctx->partsLen - 1;
+   for (size_t i = 0; i < ctx->partsLen; i++)
+      len += ctx->partLengths[i];
+
+   wchar_t *newCwd = xCalloc(len + 1, sizeof(wchar_t));
+
+   newCwd[0] = '\0';
+   for (size_t i = 0, writeIndex = 0; i < ctx->partsLen; i++) {
+      if (!ctx->parts[i])
+         continue;
+
+      Wstring_safeWcsncpy(newCwd + writeIndex, ctx->parts[i], ctx->partLengths[i] + 1);
+      writeIndex += ctx->partLengths[i];
+      if (i < ctx->partsLen - 1)
+         newCwd[writeIndex++] = L'/';
+   }
+
+   return newCwd;
+}
+
+char* CwdUtils_shortenCwd(char *cwd, const size_t maxLength) {
+   wchar_t *wcwd = xMbstowcs(cwd);
+   size_t len = wcslen(wcwd);
+   if (len <= maxLength) {
+      free(wcwd);
+      return xStrdup(cwd);
+   }
+
+   ShortenCwdContext ctx = {
+      .maxLength = maxLength,
+      .len = len,
+   };
+   ctx.parts = Wstring_split(wcwd, L'/', &ctx.partsLen);
+   free(wcwd);
+   wcwd = NULL;
+   ctx.partLengths = xCalloc(ctx.partsLen, sizeof(size_t));
+   for (size_t i = 0; i < ctx.partsLen; i++)
+      ctx.partLengths[i] = wcslen(ctx.parts[i]);
+
+   shortenCwdParts(&ctx);
+   if (shortenCwdLastPart(&ctx, false) > collapseCwdParts(&ctx, false)) {
+      shortenCwdLastPart(&ctx, true);
+      collapseCwdParts(&ctx, true);
+   } else {
+      collapseCwdParts(&ctx, true);
+      shortenCwdLastPart(&ctx, true);
+   }
+
+   wchar_t *newWcwd = buildCwdFromParts(&ctx);
+   char *newCwd = xWcstombs(newWcwd);
+   free(newWcwd);
+
+   free(ctx.partLengths);
+   for (size_t i = 0; i < ctx.partsLen; i++)
+      free(ctx.parts[i]);
+   free(ctx.parts);
+
+   return newCwd;
+}

CwdUtils.h

@@ -0,0 +1,8 @@
+#ifndef HEADER_CwdUtils
+#define HEADER_CwdUtils
+
+#include <stddef.h>
+
+char* CwdUtils_shortenCwd(char* cwd, size_t maxLength);
+
+#endif

Makefile.am

@@ -43,6 +43,7 @@ myhtopsources = \
 	Compat.c \
 	CPUMeter.c \
 	CRT.c \
+	CwdUtils.c \
 	DateMeter.c \
 	DateTimeMeter.c \
 	DiskIOMeter.c \
@@ -101,6 +102,7 @@ myhtopheaders = \
 	CommandLine.h \
 	CommandScreen.h \
 	Compat.h \
+	CwdUtils.h \
 	DateMeter.h \
 	DateTimeMeter.h \
 	DiskIOMeter.h \

Process.c

@@ -30,6 +30,7 @@ in the source distribution for its full text.
 #include "RichString.h"
 #include "Settings.h"
 #include "XUtils.h"
+#include "CwdUtils.h"
 
 #if defined(MAJOR_IN_MKDEV)
 #include <sys/mkdev.h>
@@ -733,6 +734,8 @@ void Process_printPercentage(float val, char* buffer, int n, int* attr) {
    }
 }
 
+
+
 void Process_writeField(const Process* this, RichString* str, ProcessField field) {
    char buffer[256];
    size_t n = sizeof(buffer);
@@ -825,7 +828,7 @@ void Process_writeField(const Process* this, RichString* str, ProcessField field
          attr = CRT_colors[PROCESS_SHADOW];
          cwd = "main thread terminated";
       } else {
-         cwd = this->procCwd;
+         cwd = this->procCwdShort;
       }
       Process_printLeftAlignedField(str, attr, cwd, 25);
       return;
@@ -955,6 +958,7 @@ void Process_done(Process* this) {
    free(this->procComm);
    free(this->procExe);
    free(this->procCwd);
+   free(this->procCwdShort);
    free(this->mergedCommand.str);
    free(this->tty_name);
 }
@@ -1238,3 +1242,8 @@ void Process_updateExe(Process* this, const char* exe) {
    }
    this->mergedCommand.exeChanged = true;
 }
+
+void Process_updateShortCwd(Process* this) {
+   free(this->procCwdShort);
+   this->procCwdShort = this->procCwd ? CwdUtils_shortenCwd(this->procCwd, 25) : NULL;
+}

Process.h

@@ -157,6 +157,9 @@ typedef struct Process_ {
    /* The process/thread working directory */
    char* procCwd;
 
+   /* Shortened process/thread working directory */
+   char* procCwdShort;
+
    /* Offset in procExe of the process basename */
    int procExeBasenameOffset;
 
@@ -388,6 +391,7 @@ const char* Process_getCommandStr(const Process* this);
 void Process_updateComm(Process* this, const char* comm);
 void Process_updateCmdline(Process* this, const char* cmdline, int basenameStart, int basenameEnd);
 void Process_updateExe(Process* this, const char* exe);
+void Process_updateShortCwd(Process* this);
 
 /* This function constructs the string that is displayed by
  * Process_writeCommand and also returned by Process_getCommandStr */

ProcessList.c

@@ -629,6 +629,8 @@ void ProcessList_scan(ProcessList* this, bool pauseProcessUpdate) {
    for (int i = Vector_size(this->processes) - 1; i >= 0; i--) {
       Process* p = (Process*) Vector_get(this->processes, i);
       Process_makeCommandStr(p);
+      if (p->settings->flags & PROCESS_FLAG_CWD)
+         Process_updateShortCwd(p);
 
       if (p->tombStampMs > 0) {
          // remove tombed process

XUtils.c

@@ -323,3 +323,83 @@ ssize_t xReadfileat(openat_arg_t dirfd, const char* pathname, void* buffer, size
 
    return readfd_internal(fd, buffer, count);
 }
+
+wchar_t* xMbstowcs(const char *mbs) {
+   size_t len = strlen(mbs);
+   wchar_t *wcs = xCalloc(len + 1, sizeof(wchar_t));
+   mbstate_t mbstate = {0};
+   mbsrtowcs(wcs, &mbs, len + 1, &mbstate);
+   if (mbs)
+      fail();
+   return wcs;
+}
+
+char* xWcstombs(const wchar_t *wcs) {
+   size_t len = wcslen(wcs);
+   size_t mbsSize = len * sizeof(wchar_t) + 1;
+   char *mbs = xMalloc(mbsSize);
+   mbstate_t mbstate = {0};
+   wcsrtombs(mbs, &wcs, mbsSize, &mbstate);
+   if (wcs)
+      fail();
+   return mbs;
+}
+
+wchar_t* xWcsdup(const wchar_t* str) {
+   wchar_t* data = wcsdup(str);
+   if (!data)
+      fail();
+   return data;
+}
+
+wchar_t* xWcsndup(const wchar_t* str, size_t len) {
+   wchar_t* data = xCalloc(len + 1, sizeof(wchar_t));
+   if (!data)
+      fail();
+
+   for (size_t i = 0; i < len && str[i]; i++)
+      data[i] = str[i];
+
+   return data;
+}
+
+wchar_t** Wstring_split(const wchar_t* s, wchar_t sep, size_t* n) {
+   const unsigned int rate = 10;
+   wchar_t** out = xCalloc(rate, sizeof(wchar_t*));
+   size_t ctr = 0;
+   unsigned int blocks = rate;
+   const wchar_t* where;
+   while ((where = wcschr(s, sep)) != NULL) {
+      size_t size = (size_t)(where - s);
+      out[ctr] = xWcsndup(s, size);
+      ctr++;
+      if (ctr == blocks) {
+         blocks += rate;
+         out = (wchar_t**) xRealloc(out, sizeof(wchar_t*) * blocks);
+      }
+      s += size + 1;
+   }
+   if (s[0] != L'\0') {
+      out[ctr] = xWcsdup(s);
+      ctr++;
+   }
+   out = xRealloc(out, sizeof(wchar_t*) * (ctr + 1));
+   out[ctr] = NULL;
+
+   if (n)
+      *n = ctr;
+
+   return out;
+}
+
+size_t Wstring_safeWcsncpy(wchar_t* restrict dest, const wchar_t* restrict src, size_t size) {
+   assert(size > 0);
+
+   size_t i = 0;
+   for (; i < size - 1 && src[i]; i++)
+      dest[i] = src[i];
+
+   dest[i] = L'\0';
+
+   return i;
+}

XUtils.h

@@ -75,4 +75,11 @@ char* xStrndup(const char* str, size_t len) ATTR_NONNULL ATTR_MALLOC;
 ssize_t xReadfile(const char* pathname, void* buffer, size_t count);
 ssize_t xReadfileat(openat_arg_t dirfd, const char* pathname, void* buffer, size_t count);
 
+wchar_t* xMbstowcs(const char *mbs);
+char* xWcstombs(const wchar_t *wcs);
+wchar_t* xWcsdup(const wchar_t* str);
+wchar_t* xWcsndup(const wchar_t* str, size_t len);
+wchar_t** Wstring_split(const wchar_t* s, wchar_t sep, size_t* n);
+size_t Wstring_safeWcsncpy(wchar_t* restrict dest, const wchar_t* restrict src, size_t size);
+
 #endif