Embracing branches

Action.c

@@ -65,13 +65,13 @@ Object* Action_pickFromVector(State* st, Panel* list, int x, bool followProcess)
          Process* selected = (Process*)Panel_getSelected(panel);
          if (selected && selected->pid == pid)
             return Panel_getSelected(list);
-         else
+
          beep();
       } else {
          return Panel_getSelected(list);
       }
-
    }
+
    return NULL;
 }
 
@@ -128,14 +128,18 @@ static void tagAllChildren(Panel* panel, Process* parent) {
 
 static bool expandCollapse(Panel* panel) {
    Process* p = (Process*) Panel_getSelected(panel);
-   if (!p) return false;
+   if (!p)
+      return false;
+
    p->showChildren = !p->showChildren;
    return true;
 }
 
 static bool collapseIntoParent(Panel* panel) {
    Process* p = (Process*) Panel_getSelected(panel);
-   if (!p) return false;
+   if (!p)
+      return false;
+
    pid_t ppid = Process_getParentPid(p);
    for (int i = 0; i < Panel_size(panel); i++) {
       Process* q = (Process*) Panel_get(panel, i);
@@ -165,6 +169,7 @@ static Htop_Reaction sortBy(State* st) {
       Panel_add(sortPanel, (Object*) ListItem_new(name, fields[i]));
       if (fields[i] == st->settings->sortKey)
          Panel_setSelected(sortPanel, i);
+
       free(name);
    }
    ListItem* field = (ListItem*) Action_pickFromVector(st, sortPanel, 15, false);
@@ -172,8 +177,10 @@ static Htop_Reaction sortBy(State* st) {
       reaction |= Action_setSortKey(st->settings, field->key);
    }
    Object_delete(sortPanel);
+
    if (st->pauseProcessUpdate)
       ProcessList_sort(st->pl);
+
    return reaction | HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
 }
 
@@ -215,7 +222,10 @@ static Htop_Reaction actionToggleProgramPath(State* st) {
 
 static Htop_Reaction actionToggleTreeView(State* st) {
    st->settings->treeView = !st->settings->treeView;
-   if (st->settings->treeView) st->settings->direction = 1;
+   if (st->settings->treeView) {
+      st->settings->direction = 1;
+   }
+
    ProcessList_expandTree(st->pl);
    return HTOP_REFRESH | HTOP_SAVE_SETTINGS | HTOP_KEEP_FOLLOWING | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
 }
@@ -286,13 +296,18 @@ static Htop_Reaction actionQuit(ATTR_UNUSED State* st) {
 static Htop_Reaction actionSetAffinity(State* st) {
    if (st->pl->cpuCount == 1)
       return HTOP_OK;
+
 #if (defined(HAVE_LIBHWLOC) || defined(HAVE_LINUX_AFFINITY))
    Panel* panel = st->panel;
 
    Process* p = (Process*) Panel_getSelected(panel);
-   if (!p) return HTOP_OK;
+   if (!p)
+      return HTOP_OK;
+
    Affinity* affinity1 = Affinity_get(p, st->pl);
-   if (!affinity1) return HTOP_OK;
+   if (!affinity1)
+      return HTOP_OK;
+
    int width;
    Panel* affinityPanel = AffinityPanel_new(st->pl, affinity1, &width);
    width += 1; /* we add a gap between the panels */
@@ -302,7 +317,8 @@ static Htop_Reaction actionSetAffinity(State* st) {
    if (set) {
       Affinity* affinity2 = AffinityPanel_getAffinity(affinityPanel, st->pl);
       bool ok = MainPanel_foreachProcess((MainPanel*)panel, Affinity_set, (Arg) { .v = affinity2 }, NULL);
-      if (!ok) beep();
+      if (!ok)
+         beep();
       Affinity_delete(affinity2);
    }
    Object_delete(affinityPanel);
@@ -362,7 +378,9 @@ static Htop_Reaction actionSetup(State* st) {
 
 static Htop_Reaction actionLsof(State* st) {
    Process* p = (Process*) Panel_getSelected(st->panel);
-   if (!p) return HTOP_OK;
+   if (!p)
+      return HTOP_OK;
+
    OpenFilesScreen* ofs = OpenFilesScreen_new(p);
    InfoScreen_run((InfoScreen*)ofs);
    OpenFilesScreen_delete((Object*)ofs);
@@ -373,7 +391,9 @@ static Htop_Reaction actionLsof(State* st) {
 
 static Htop_Reaction actionStrace(State* st) {
    Process* p = (Process*) Panel_getSelected(st->panel);
-   if (!p) return HTOP_OK;
+   if (!p)
+      return HTOP_OK;
+
    TraceScreen* ts = TraceScreen_new(p);
    bool ok = TraceScreen_forkTracer(ts);
    if (ok) {
@@ -387,7 +407,9 @@ static Htop_Reaction actionStrace(State* st) {
 
 static Htop_Reaction actionTag(State* st) {
    Process* p = (Process*) Panel_getSelected(st->panel);
-   if (!p) return HTOP_OK;
+   if (!p)
+      return HTOP_OK;
+
    Process_toggleTag(p);
    Panel_onKey(st->panel, KEY_DOWN);
    return HTOP_OK;
@@ -555,14 +577,18 @@ static Htop_Reaction actionUntagAll(State* st) {
 
 static Htop_Reaction actionTagAllChildren(State* st) {
    Process* p = (Process*) Panel_getSelected(st->panel);
-   if (!p) return HTOP_OK;
+   if (!p)
+      return HTOP_OK;
+
    tagAllChildren(st->panel, p);
    return HTOP_OK;
 }
 
 static Htop_Reaction actionShowEnvScreen(State* st) {
    Process* p = (Process*) Panel_getSelected(st->panel);
-   if (!p) return HTOP_OK;
+   if (!p)
+      return HTOP_OK;
+
    EnvScreen* es = EnvScreen_new(p);
    InfoScreen_run((InfoScreen*)es);
    EnvScreen_delete((Object*)es);
@@ -573,7 +599,9 @@ static Htop_Reaction actionShowEnvScreen(State* st) {
 
 static Htop_Reaction actionShowCommandScreen(State* st) {
    Process* p = (Process*) Panel_getSelected(st->panel);
-   if (!p) return HTOP_OK;
+   if (!p)
+      return HTOP_OK;
+
    CommandScreen* cmdScr = CommandScreen_new(p);
    InfoScreen_run((InfoScreen*)cmdScr);
    CommandScreen_delete((Object*)cmdScr);

Affinity.c

@@ -89,12 +89,15 @@ bool Affinity_set(Process* proc, Arg arg) {
 Affinity* Affinity_get(Process* proc, ProcessList* pl) {
    cpu_set_t cpuset;
    bool ok = (sched_getaffinity(proc->pid, sizeof(cpu_set_t), &cpuset) == 0);
-   if (!ok) return NULL;
+   if (!ok)
+      return NULL;
+
    Affinity* affinity = Affinity_new(pl);
    for (int i = 0; i < pl->cpuCount; i++) {
-      if (CPU_ISSET(i, &cpuset))
+      if (CPU_ISSET(i, &cpuset)) {
          Affinity_add(affinity, i);
       }
+   }
    return affinity;
 }
 

AffinityPanel.c

@@ -60,12 +60,13 @@ static void MaskItem_display(const Object* cast, RichString* out) {
    const MaskItem* this = (const MaskItem*)cast;
    assert (this != NULL);
    RichString_append(out, CRT_colors[CHECK_BOX], "[");
-   if (this->value == 2)
+   if (this->value == 2) {
       RichString_append(out, CRT_colors[CHECK_MARK], "x");
-   else if (this->value == 1)
+   } else if (this->value == 1) {
       RichString_append(out, CRT_colors[CHECK_MARK], "o");
-   else
+   } else {
       RichString_append(out, CRT_colors[CHECK_MARK], " ");
+   }
    RichString_append(out, CRT_colors[CHECK_BOX], "]");
    RichString_append(out, CRT_colors[CHECK_TEXT], " ");
    if (this->indent) {
@@ -178,12 +179,13 @@ static void AffinityPanel_update(AffinityPanel* this, bool keepSelected) {
    Panel_prune(super);
 
    #ifdef HAVE_LIBHWLOC
-   if (this->topoView)
+   if (this->topoView) {
       AffinityPanel_updateTopo(this, this->topoRoot);
-   else {
+   } else {
-      for (int i = 0; i < Vector_size(this->cpuids); i++)
+      for (int i = 0; i < Vector_size(this->cpuids); i++) {
          AffinityPanel_updateItem(this, (MaskItem*) Vector_get(this->cpuids, i));
       }
+   }
    #else
    Panel_splice(super, this->cpuids);
    #endif
@@ -304,14 +306,16 @@ static MaskItem* AffinityPanel_addObject(AffinityPanel* this, hwloc_obj_t obj, u
       hwloc_bitmap_and(result, obj->complete_cpuset, this->workCpuset);
       int weight = hwloc_bitmap_weight(result);
       hwloc_bitmap_free(result);
-      if (weight == 0 || weight == (hwloc_bitmap_weight(this->workCpuset) + hwloc_bitmap_weight(obj->complete_cpuset)))
+      if (weight == 0 || weight == (hwloc_bitmap_weight(this->workCpuset) + hwloc_bitmap_weight(obj->complete_cpuset))) {
          item->sub_tree = 2;
       }
+   }
 
    /* "[x] " + "|- " * depth + ("- ")?(if root node) + name */
    unsigned width = 4 + 3 * depth + (2 * !depth) + strlen(buf);
-   if (width > this->width)
+   if (width > this->width) {
       this->width = width;
+   }
 
    return item;
 }
@@ -323,8 +327,10 @@ static MaskItem* AffinityPanel_buildTopology(AffinityPanel* this, hwloc_obj_t ob
    } else {
       indent &= ~(1u << obj->depth);
    }
-   for (unsigned i = 0; i < obj->arity; i++)
+
+   for (unsigned i = 0; i < obj->arity; i++) {
       AffinityPanel_buildTopology(this, obj->children[i], indent, item);
+   }
 
    return parent == NULL ? item : NULL;
 }
@@ -382,8 +388,9 @@ Panel* AffinityPanel_new(ProcessList* pl, Affinity* affinity, int* width) {
       char number[16];
       xSnprintf(number, 9, "CPU %d", Settings_cpuId(pl->settings, i));
       unsigned cpu_width = 4 + strlen(number);
-      if (cpu_width > this->width)
+      if (cpu_width > this->width) {
          this->width = cpu_width;
+      }
 
       bool isSet = false;
       if (curCpu < affinity->used && affinity->cpus[curCpu] == i) {
@@ -402,8 +409,9 @@ Panel* AffinityPanel_new(ProcessList* pl, Affinity* affinity, int* width) {
    this->topoRoot = AffinityPanel_buildTopology(this, hwloc_get_root_obj(pl->topology), 0, NULL);
    #endif
 
-   if (width)
+   if (width) {
       *width = this->width;
+   }
 
    AffinityPanel_update(this, false);
 
@@ -422,9 +430,10 @@ Affinity* AffinityPanel_getAffinity(Panel* super, ProcessList* pl) {
    #else
    for (int i = 0; i < this->pl->cpuCount; i++) {
       MaskItem* item = (MaskItem*)Vector_get(this->cpuids, i);
-      if (item->value)
+      if (item->value) {
          Affinity_add(affinity, item->cpu);
       }
+   }
    #endif
 
    return affinity;

CPUMeter.c

@@ -163,10 +163,13 @@ static void CPUMeterCommonInit(Meter* this, int ncol) {
    for (int i = 0; i < count; i++) {
       if (!meters[i])
          meters[i] = Meter_new(this->pl, start + i + 1, (const MeterClass*) Class(CPUMeter));
+
       Meter_init(meters[i]);
    }
+
    if (this->mode == 0)
       this->mode = BAR_METERMODE;
+
    int h = Meter_modes[this->mode]->h;
    this->h = h * ((count + ncol - 1) / ncol);
 }

CRT.c

@@ -619,13 +619,18 @@ void CRT_init(int delay, int colorScheme, bool allowUnicode) {
    keypad(stdscr, true);
    mouseinterval(0);
    curs_set(0);
-   if (has_colors())
+
+   if (has_colors()) {
       start_color();
+   }
+
    CRT_termType = getenv("TERM");
-   if (String_eq(CRT_termType, "linux"))
+   if (String_eq(CRT_termType, "linux")) {
       CRT_scrollHAmount = 20;
-   else
+   } else {
       CRT_scrollHAmount = 5;
+   }
+
    if (String_startsWith(CRT_termType, "xterm") || String_eq(CRT_termType, "vt220")) {
       define_key("\033[H", KEY_HOME);
       define_key("\033[F", KEY_END);
@@ -670,10 +675,11 @@ void CRT_init(int delay, int colorScheme, bool allowUnicode) {
    setlocale(LC_CTYPE, "");
 
 #ifdef HAVE_LIBNCURSESW
-   if (allowUnicode && String_eq(nl_langinfo(CODESET), "UTF-8"))
+   if (allowUnicode && String_eq(nl_langinfo(CODESET), "UTF-8")) {
       CRT_utf8 = true;
-   else
+   } else {
       CRT_utf8 = false;
+   }
 #else
    (void) allowUnicode;
 #endif

CategoriesPanel.c

@@ -97,6 +97,7 @@ static HandlerResult CategoriesPanel_eventHandler(Panel* super, int ch) {
       int size = ScreenManager_size(this->scr);
       for (int i = 1; i < size; i++)
          ScreenManager_remove(this->scr, 1);
+
       switch (selected) {
          case 0:
             CategoriesPanel_makeMetersPage(this);

CheckItem.c

@@ -26,10 +26,11 @@ static void CheckItem_display(const Object* cast, RichString* out) {
    const CheckItem* this = (const CheckItem*)cast;
    assert (this != NULL);
    RichString_write(out, CRT_colors[CHECK_BOX], "[");
-   if (CheckItem_get(this))
+   if (CheckItem_get(this)) {
       RichString_append(out, CRT_colors[CHECK_MARK], "x");
-   else
+   } else {
       RichString_append(out, CRT_colors[CHECK_MARK], " ");
+   }
    RichString_append(out, CRT_colors[CHECK_BOX], "] ");
    RichString_append(out, CRT_colors[CHECK_TEXT], this->text);
 }
@@ -56,15 +57,17 @@ CheckItem* CheckItem_newByVal(char* text, bool value) {
 }
 
 void CheckItem_set(CheckItem* this, bool value) {
-   if (this->ref)
+   if (this->ref) {
       *(this->ref) = value;
-   else
+   } else {
       this->value = value;
    }
+}
 
 bool CheckItem_get(const CheckItem* this) {
-   if (this->ref)
+   if (this->ref) {
       return *(this->ref);
-   else
+   } else {
       return this->value;
    }
+}

ColorsPanel.c

@@ -64,6 +64,7 @@ static HandlerResult ColorsPanel_eventHandler(Panel* super, int ch) {
       for (int i = 0; ColorSchemeNames[i] != NULL; i++)
          CheckItem_set((CheckItem*)Panel_get(super, i), false);
       CheckItem_set((CheckItem*)Panel_get(super, mark), true);
+
       this->settings->colorScheme = mark;
       result = HANDLED;
    }

CommandScreen.c

@@ -21,7 +21,9 @@ static void CommandScreen_scan(InfoScreen* this) {
    int line_offset = 0, last_spc = -1, len;
    for (; *p != '\0'; p++, line_offset++) {
       line[line_offset] = *p;
-      if (*p == ' ') last_spc = line_offset;
+      if (*p == ' ') {
+         last_spc = line_offset;
+      }
 
       if (line_offset == COLS) {
          len = (last_spc == -1) ? line_offset : last_spc;

FunctionBar.c

@@ -106,10 +106,11 @@ void FunctionBar_drawExtra(const FunctionBar* this, const char* buffer, int attr
    }
 
    if (buffer) {
-      if (attr == -1)
+      if (attr == -1) {
          attrset(CRT_colors[FUNCTION_BAR]);
-      else
+      } else {
          attrset(attr);
+      }
       mvaddstr(LINES - 1, x, buffer);
       attrset(CRT_colors[RESET_COLOR]);
       x += strlen(buffer);
@@ -126,10 +127,11 @@ void FunctionBar_drawExtra(const FunctionBar* this, const char* buffer, int attr
 }
 
 void FunctionBar_append(const char* buffer, int attr) {
-   if (attr == -1)
+   if (attr == -1) {
       attrset(CRT_colors[FUNCTION_BAR]);
-   else
+   } else {
       attrset(attr);
+   }
    mvaddstr(LINES - 1, currentLen, buffer);
    attrset(CRT_colors[RESET_COLOR]);
 

Hashtable.c

@@ -70,6 +70,7 @@ void Hashtable_delete(Hashtable* this) {
       while (walk != NULL) {
          if (this->owner)
             free(walk->value);
+
          HashtableItem* savedWalk = walk;
          walk = savedWalk->next;
          free(savedWalk);
@@ -90,10 +91,13 @@ void Hashtable_put(Hashtable* this, unsigned int key, void* value) {
       } else if ((*bucketPtr)->key == key) {
          if (this->owner && (*bucketPtr)->value != value)
             free((*bucketPtr)->value);
+
          (*bucketPtr)->value = value;
          break;
-      } else
+      } else {
          bucketPtr = &((*bucketPtr)->next);
+      }
+
    assert(Hashtable_isConsistent(this));
 }
 
@@ -134,10 +138,11 @@ void* Hashtable_get(Hashtable* this, unsigned int key) {
       } else if (bucketPtr->key == key) {
          assert(Hashtable_isConsistent(this));
          return bucketPtr->value;
-      } else
+      } else {
          bucketPtr = bucketPtr->next;
       }
    }
+}
 
 void Hashtable_foreach(Hashtable* this, Hashtable_PairFunction f, void* userData) {
    assert(Hashtable_isConsistent(this));

Header.c

@@ -88,7 +88,8 @@ MeterModeId Header_addMeterByName(Header* this, char* name, int column) {
    int param = 0;
    if (paren) {
       int ok = sscanf(paren, "(%10d)", &param);
-      if (!ok) param = 0;
+      if (!ok)
+         param = 0;
       *paren = '\0';
    }
    MeterModeId mode = TEXT_METERMODE;
@@ -100,8 +101,10 @@ MeterModeId Header_addMeterByName(Header* this, char* name, int column) {
          break;
       }
    }
+
    if (paren)
       *paren = '(';
+
    return mode;
 }
 
@@ -110,6 +113,7 @@ void Header_setMode(Header* this, int i, MeterModeId mode, int column) {
 
    if (i >= Vector_size(meters))
       return;
+
    Meter* meter = (Meter*) Vector_get(meters, i);
    Meter_setMode(meter, mode);
 }
@@ -153,11 +157,12 @@ void Header_reinit(Header* this) {
    Header_forEachColumn(this, col) {
       for (int i = 0; i < Vector_size(this->columns[col]); i++) {
          Meter* meter = (Meter*) Vector_get(this->columns[col], i);
-         if (Meter_initFn(meter))
+         if (Meter_initFn(meter)) {
             Meter_init(meter);
          }
       }
    }
+}
 
 void Header_draw(const Header* this) {
    int height = this->height;

IncSet.c

@@ -79,7 +79,10 @@ static void updateWeakPanel(IncSet* this, Panel* panel, Vector* lines) {
          ListItem* line = (ListItem*)Vector_get(lines, i);
          if (String_contains_i(line->value, incFilter)) {
             Panel_add(panel, (Object*)line);
-            if (selected == (Object*)line) Panel_setSelected(panel, n);
+            if (selected == (Object*)line) {
+               Panel_setSelected(panel, n);
+            }
+
             n++;
          }
       }
@@ -87,7 +90,9 @@ static void updateWeakPanel(IncSet* this, Panel* panel, Vector* lines) {
       for (int i = 0; i < Vector_size(lines); i++) {
          Object* line = Vector_get(lines, i);
          Panel_add(panel, line);
-         if (selected == line) Panel_setSelected(panel, i);
+         if (selected == line) {
+            Panel_setSelected(panel, i);
+         }
       }
    }
 }
@@ -116,9 +121,16 @@ static bool IncMode_find(IncMode* mode, Panel* panel, IncMode_GetPanelValue getP
    int i = here;
    for (;;) {
       i += step;
-      if (i == size) i = 0;
+      if (i == size) {
-      if (i == -1) i = size - 1;
+         i = 0;
-      if (i == here) return false;
+      }
+      if (i == -1) {
+         i = size - 1;
+      }
+      if (i == here) {
+         return false;
+      }
+
       if (String_contains_i(getPanelValue(panel, i), mode->buffer)) {
          Panel_setSelected(panel, i);
          return true;
@@ -137,12 +149,15 @@ bool IncSet_prev(IncSet* this, IncType type, Panel* panel, IncMode_GetPanelValue
 bool IncSet_handleKey(IncSet* this, int ch, Panel* panel, IncMode_GetPanelValue getPanelValue, Vector* lines) {
    if (ch == ERR)
       return true;
+
    IncMode* mode = this->active;
    int size = Panel_size(panel);
    bool filterChanged = false;
    bool doSearch = true;
    if (ch == KEY_F(3)) {
-      if (size == 0) return true;
+      if (size == 0)
+         return true;
+
       IncMode_find(mode, panel, getPanelValue, 1);
       doSearch = false;
    } else if (0 < ch && ch < 255 && isprint((unsigned char)ch)) {
@@ -152,7 +167,9 @@ bool IncSet_handleKey(IncSet* this, int ch, Panel* panel, IncMode_GetPanelValue
          mode->buffer[mode->index] = 0;
          if (mode->isFilter) {
             filterChanged = true;
-            if (mode->index == 1) this->filtering = true;
+            if (mode->index == 1) {
+               this->filtering = true;
+            }
          }
       }
    } else if ((ch == KEY_BACKSPACE || ch == 127)) {
@@ -199,9 +216,7 @@ bool IncSet_handleKey(IncSet* this, int ch, Panel* panel, IncMode_GetPanelValue
 
 const char* IncSet_getListItemValue(Panel* panel, int i) {
    ListItem* l = (ListItem*) Panel_get(panel, i);
-   if (l)
+   return l ? l->value : "";
-      return l->value;
-   return "";
 }
 
 void IncSet_activate(IncSet* this, IncType type, Panel* panel) {

InfoScreen.c

@@ -64,17 +64,19 @@ void InfoScreen_drawTitled(InfoScreen* this, const char* fmt, ...) {
 void InfoScreen_addLine(InfoScreen* this, const char* line) {
    Vector_add(this->lines, (Object*) ListItem_new(line, 0));
    const char* incFilter = IncSet_filter(this->inc);
-   if (!incFilter || String_contains_i(line, incFilter))
+   if (!incFilter || String_contains_i(line, incFilter)) {
       Panel_add(this->display, Vector_get(this->lines, Vector_size(this->lines) - 1));
    }
+}
 
 void InfoScreen_appendLine(InfoScreen* this, const char* line) {
    ListItem* last = (ListItem*)Vector_get(this->lines, Vector_size(this->lines) - 1);
    ListItem_append(last, line);
    const char* incFilter = IncSet_filter(this->inc);
-   if (incFilter && Panel_get(this->display, Panel_size(this->display) - 1) != (Object*)last && String_contains_i(line, incFilter))
+   if (incFilter && Panel_get(this->display, Panel_size(this->display) - 1) != (Object*)last && String_contains_i(line, incFilter)) {
       Panel_add(this->display, (Object*)last);
    }
+}
 
 void InfoScreen_run(InfoScreen* this) {
    Panel* panel = this->display;
@@ -133,7 +135,9 @@ void InfoScreen_run(InfoScreen* this) {
          break;
       case KEY_F(5):
          clear();
-         if (As_InfoScreen(this)->scan) InfoScreen_scan(this);
+         if (As_InfoScreen(this)->scan)
+            InfoScreen_scan(this);
+
          InfoScreen_draw(this);
          break;
       case '\014': // Ctrl+L
@@ -149,6 +153,7 @@ void InfoScreen_run(InfoScreen* this) {
          Panel_resize(panel, COLS, LINES - 2);
          if (As_InfoScreen(this)->scan)
             InfoScreen_scan(this);
+
          InfoScreen_draw(this);
          break;
       default:

MainPanel.c

@@ -100,9 +100,10 @@ static HandlerResult MainPanel_eventHandler(Panel* super, int ch) {
    if (reaction & HTOP_REDRAW_BAR) {
       MainPanel_updateTreeFunctions(this, this->state->settings->treeView);
       IncSet_drawBar(this->inc);
-      if (this->state->pauseProcessUpdate)
+      if (this->state->pauseProcessUpdate) {
          FunctionBar_append("PAUSED", CRT_colors[PAUSED]);
       }
+   }
    if (reaction & HTOP_UPDATE_PANELHDR) {
       ProcessList_printHeader(this->state->pl, Panel_getHeader(super));
    }
@@ -135,9 +136,7 @@ int MainPanel_selectedPid(MainPanel* this) {
 
 const char* MainPanel_getValue(MainPanel* this, int i) {
    Process* p = (Process*) Panel_get((Panel*)this, i);
-   if (p)
+   return p ? p->comm : "";
-      return p->comm;
-   return "";
 }
 
 bool MainPanel_foreachProcess(MainPanel* this, MainPanel_ForeachProcessFn fn, Arg arg, bool* wasAnyTagged) {
@@ -157,8 +156,10 @@ bool MainPanel_foreachProcess(MainPanel* this, MainPanel_ForeachProcessFn fn, Ar
          ok &= fn(p, arg);
       }
    }
+
    if (wasAnyTagged)
       *wasAnyTagged = anyTagged;
+
    return ok;
 }
 

Meter.c

@@ -41,8 +41,9 @@ Meter* Meter_new(const struct ProcessList_* pl, int param, const MeterClass* typ
    this->values = type->maxItems ? xCalloc(type->maxItems, sizeof(double)) : NULL;
    this->total = type->total;
    this->caption = xStrdup(type->caption);
-   if (Meter_initFn(this))
+   if (Meter_initFn(this)) {
       Meter_init(this);
+   }
    Meter_setMode(this, type->defaultMode);
    return this;
 }
@@ -81,6 +82,7 @@ int Meter_humanUnit(char* buffer, unsigned long int value, int size) {
 void Meter_delete(Object* cast) {
    if (!cast)
       return;
+
    Meter* this = (Meter*) cast;
    if (Meter_doneFn(this)) {
       Meter_done(this);
@@ -105,15 +107,20 @@ static inline void Meter_displayBuffer(const Meter* this, const char* buffer, Ri
 }
 
 void Meter_setMode(Meter* this, int modeIndex) {
-   if (modeIndex > 0 && modeIndex == this->mode)
+   if (modeIndex > 0 && modeIndex == this->mode) {
       return;
-   if (!modeIndex)
+   }
+
+   if (!modeIndex) {
       modeIndex = 1;
+   }
+
    assert(modeIndex < LAST_METERMODE);
    if (Meter_defaultMode(this) == CUSTOM_METERMODE) {
       this->draw = Meter_drawFn(this);
-      if (Meter_updateModeFn(this))
+      if (Meter_updateModeFn(this)) {
          Meter_updateMode(this, modeIndex);
+      }
    } else {
       assert(modeIndex >= 1);
       free(this->drawData);
@@ -128,15 +135,17 @@ void Meter_setMode(Meter* this, int modeIndex) {
 
 ListItem* Meter_toListItem(Meter* this, bool moving) {
    char mode[21];
-   if (this->mode)
+   if (this->mode) {
       xSnprintf(mode, 20, " [%s]", Meter_modes[this->mode]->uiName);
-   else
+   } else {
       mode[0] = '\0';
+   }
    char number[11];
-   if (this->param > 0)
+   if (this->param > 0) {
       xSnprintf(number, 10, " %d", this->param);
-   else
+   } else {
       number[0] = '\0';
+   }
    char buffer[51];
    xSnprintf(buffer, 50, "%s%s%s", Meter_uiName(this), number, mode);
    ListItem* li = ListItem_new(buffer, 0);
@@ -261,7 +270,9 @@ static int GraphMeterMode_pixPerRow;
 
 static void GraphMeterMode_draw(Meter* this, int x, int y, int w) {
 
-   if (!this->drawData) this->drawData = xCalloc(1, sizeof(GraphData));
+   if (!this->drawData) {
+      this->drawData = xCalloc(1, sizeof(GraphData));
+   }
    GraphData* data = this->drawData;
    const int nValues = METER_BUFFER_LEN;
 

Object.c

@@ -20,12 +20,16 @@ const ObjectClass Object_class = {
 bool Object_isA(const Object* o, const ObjectClass* klass) {
    if (!o)
       return false;
+
    const ObjectClass* type = o->klass;
    while (type) {
-      if (type == klass)
+      if (type == klass) {
          return true;
+      }
+
       type = type->extends;
    }
+
    return false;
 }
 

OpenFilesScreen.c

@@ -69,10 +69,11 @@ static const char* getDataForType(const OpenFiles_Data* data, char type) {
 OpenFilesScreen* OpenFilesScreen_new(const Process* process) {
    OpenFilesScreen* this = xMalloc(sizeof(OpenFilesScreen));
    Object_setClass(this, Class(OpenFilesScreen));
-   if (Process_isThread(process))
+   if (Process_isThread(process)) {
       this->pid = process->tgid;
-   else
+   } else {
       this->pid = process->pid;
+   }
    return (OpenFilesScreen*) InfoScreen_init(&this->super, process, NULL, LINES - 3, "   FD TYPE    MODE DEVICE           SIZE       NODE  NAME");
 }
 
@@ -106,8 +107,10 @@ static OpenFiles_ProcessData* OpenFilesScreen_getProcessData(pid_t pid) {
       dup2(fdpair[1], STDOUT_FILENO);
       close(fdpair[1]);
       int fdnull = open("/dev/null", O_WRONLY);
-      if (fdnull < 0)
+      if (fdnull < 0) {
          exit(1);
+      }
+
       dup2(fdnull, STDERR_FILENO);
       close(fdnull);
       char buffer[32] = {0};
@@ -182,10 +185,11 @@ static OpenFiles_ProcessData* OpenFilesScreen_getProcessData(pid_t pid) {
       return pdata;
    }
 
-   if (!WIFEXITED(wstatus))
+   if (!WIFEXITED(wstatus)) {
       pdata->error = 1;
-   else
+   } else {
       pdata->error = WEXITSTATUS(wstatus);
+   }
 
    return pdata;
 }

Panel.c

@@ -97,8 +97,10 @@ void Panel_move(Panel* this, int x, int y) {
 void Panel_resize(Panel* this, int w, int h) {
    assert (this != NULL);
 
-   if (RichString_sizeVal(this->header) > 0)
+   if (RichString_sizeVal(this->header) > 0) {
       h--;
+   }
+
    this->w = w;
    this->h = h;
    this->needsRedraw = true;
@@ -145,34 +147,39 @@ Object* Panel_remove(Panel* this, int i) {
 
    this->needsRedraw = true;
    Object* removed = Vector_remove(this->items, i);
-   if (this->selected > 0 && this->selected >= Vector_size(this->items))
+   if (this->selected > 0 && this->selected >= Vector_size(this->items)) {
       this->selected--;
+   }
+
    return removed;
 }
 
 Object* Panel_getSelected(Panel* this) {
    assert (this != NULL);
-   if (Vector_size(this->items) > 0)
+   if (Vector_size(this->items) > 0) {
       return Vector_get(this->items, this->selected);
-   else
+   } else {
       return NULL;
    }
+}
 
 void Panel_moveSelectedUp(Panel* this) {
    assert (this != NULL);
 
    Vector_moveUp(this->items, this->selected);
-   if (this->selected > 0)
+   if (this->selected > 0) {
       this->selected--;
    }
+}
 
 void Panel_moveSelectedDown(Panel* this) {
    assert (this != NULL);
 
    Vector_moveDown(this->items, this->selected);
-   if (this->selected + 1 < Vector_size(this->items))
+   if (this->selected + 1 < Vector_size(this->items)) {
       this->selected++;
    }
+}
 
 int Panel_getSelectedIndex(Panel* this) {
    assert (this != NULL);
@@ -193,8 +200,9 @@ void Panel_setSelected(Panel* this, int selected) {
    if (selected >= size) {
       selected = size - 1;
    }
-   if (selected < 0)
+   if (selected < 0) {
       selected = 0;
+   }
    this->selected = selected;
    if (Panel_eventHandlerFn(this)) {
       Panel_eventHandler(this, EVENT_SET_SELECTED);

Process.c

@@ -43,7 +43,9 @@ static char Process_titleBuffer[20][20];
 
 void Process_setupColumnWidths() {
    int maxPid = Platform_getMaxPid();
-   if (maxPid == -1) return;
+   if (maxPid == -1)
+      return;
+
    int digits = ceil(log10(maxPid));
    assert(digits < 20);
    for (int i = 0; Process_pidColumns[i].label; i++) {
@@ -201,10 +203,11 @@ static inline void Process_writeCommand(const Process* this, int attr, int basea
          }
       }
       if (!finish) {
-         if (this->settings->showProgramPath)
+         if (this->settings->showProgramPath) {
             start += basename;
-         else
+         } else {
             comm += basename;
+         }
          finish = this->basenameOffset - basename;
       }
       finish += start - 1;
@@ -212,9 +215,10 @@ static inline void Process_writeCommand(const Process* this, int attr, int basea
 
    RichString_append(str, attr, comm);
 
-   if (this->settings->highlightBaseName)
+   if (this->settings->highlightBaseName) {
       RichString_setAttrn(str, baseattr, start, finish);
    }
+}
 
 void Process_outputRate(RichString* str, char* buffer, int n, double rate, int coloring) {
    int largeNumberColor = CRT_colors[LARGE_NUMBER];
@@ -285,15 +289,19 @@ void Process_writeField(const Process* this, RichString* str, ProcessField field
          bool lastItem = (this->indent < 0);
          int indent = (this->indent < 0 ? -this->indent : this->indent);
 
-         for (int i = 0; i < 32; i++)
+         for (int i = 0; i < 32; i++) {
-            if (indent & (1U << i))
+            if (indent & (1U << i)) {
                maxIndent = i + 1;
+            }
+         }
+
          for (int i = 0; i < maxIndent - 1; i++) {
             int written, ret;
-            if (indent & (1 << i))
+            if (indent & (1 << i)) {
                ret = snprintf(buf, n, "%s  ", CRT_treeStr[TREE_STR_VERT]);
-            else
+            } else {
                ret = snprintf(buf, n, "   ");
+            }
             if (ret < 0 || ret >= n) {
                written = n;
             } else {
@@ -377,10 +385,15 @@ void Process_display(const Object* cast, RichString* out) {
    RichString_prune(out);
    for (int i = 0; fields[i]; i++)
       As_Process(this)->writeField(this, out, fields[i]);
-   if (this->settings->shadowOtherUsers && (int)this->st_uid != Process_getuid)
+
+   if (this->settings->shadowOtherUsers && (int)this->st_uid != Process_getuid) {
       RichString_setAttr(out, CRT_colors[PROCESS_SHADOW]);
-   if (this->tag == true)
+   }
+
+   if (this->tag == true) {
       RichString_setAttr(out, CRT_colors[PROCESS_TAG]);
+   }
+
    assert(out->chlen > 0);
 }
 
@@ -406,7 +419,10 @@ void Process_init(Process* this, const struct Settings_* settings) {
    this->show = true;
    this->updated = false;
    this->basenameOffset = -1;
-   if (Process_getuid == -1) Process_getuid = getuid();
+
+   if (Process_getuid == -1) {
+      Process_getuid = getuid();
+   }
 }
 
 void Process_toggleTag(Process* this) {
@@ -483,11 +499,12 @@ long Process_compare(const void* v1, const void* v2) {
    case SESSION:
       return (p1->session - p2->session);
    case STARTTIME: {
-      if (p1->starttime_ctime == p2->starttime_ctime)
+      if (p1->starttime_ctime == p2->starttime_ctime) {
          return (p1->pid - p2->pid);
-      else
+      } else {
          return (p1->starttime_ctime - p2->starttime_ctime);
       }
+   }
    case STATE:
       return (Process_sortState(p1->state) - Process_sortState(p2->state));
    case ST_UID:

ProcessList.c

@@ -70,13 +70,17 @@ void ProcessList_printHeader(ProcessList* this, RichString* header) {
    const ProcessField* fields = this->settings->fields;
    for (int i = 0; fields[i]; i++) {
       const char* field = Process_fields[fields[i]].title;
-      if (!field) field = "- ";
+      if (!field) {
-      if (!this->settings->treeView && this->settings->sortKey == fields[i])
+         field = "- ";
+      }
+
+      if (!this->settings->treeView && this->settings->sortKey == fields[i]) {
          RichString_append(header, CRT_colors[PANEL_SELECTION_FOCUS], field);
-      else
+      } else {
          RichString_append(header, CRT_colors[PANEL_HEADER_FOCUS], field);
       }
    }
+}
 
 void ProcessList_add(ProcessList* this, Process* p) {
    assert(Vector_indexOf(this->processes, p, Process_pidCompare) == -1);
@@ -93,12 +97,18 @@ void ProcessList_add(ProcessList* this, Process* p) {
 void ProcessList_remove(ProcessList* this, Process* p) {
    assert(Vector_indexOf(this->processes, p, Process_pidCompare) != -1);
    assert(Hashtable_get(this->processTable, p->pid) != NULL);
+
    Process* pp = Hashtable_remove(this->processTable, p->pid);
    assert(pp == p); (void)pp;
+
    unsigned int pid = p->pid;
    int idx = Vector_indexOf(this->processes, p, Process_pidCompare);
    assert(idx != -1);
-   if (idx >= 0) Vector_remove(this->processes, idx);
+
+   if (idx >= 0) {
+      Vector_remove(this->processes, idx);
+   }
+
    assert(Hashtable_get(this->processTable, pid) == NULL); (void)pid;
    assert(Hashtable_count(this->processTable) == Vector_count(this->processes));
 }
@@ -124,21 +134,28 @@ static void ProcessList_buildTree(ProcessList* this, pid_t pid, int level, int i
    int size = Vector_size(children);
    for (int i = 0; i < size; i++) {
       Process* process = (Process*) (Vector_get(children, i));
-      if (!show)
+      if (!show) {
          process->show = false;
+      }
+
       int s = Vector_size(this->processes2);
-      if (direction == 1)
+      if (direction == 1) {
          Vector_add(this->processes2, process);
-      else
+      } else {
          Vector_insert(this->processes2, 0, process);
+      }
+
       assert(Vector_size(this->processes2) == s + 1); (void)s;
+
       int nextIndent = indent | (1 << level);
       ProcessList_buildTree(this, process->pid, level + 1, (i < size - 1) ? nextIndent : indent, direction, show ? process->showChildren : false);
-      if (i == size - 1)
+
+      if (i == size - 1) {
          process->indent = -nextIndent;
-      else
+      } else {
          process->indent = nextIndent;
       }
+   }
    Vector_delete(children);
 }
 
@@ -180,6 +197,7 @@ void ProcessList_sort(ProcessList* this) {
             // root.
             if (process->pid == ppid)
                r = 0;
+
             while (l < r) {
                int c = (l + r) / 2;
                pid_t pid = ((Process*)(Vector_get(this->processes, c)))->pid;
@@ -219,7 +237,10 @@ ProcessField ProcessList_keyAt(ProcessList* this, int at) {
    ProcessField field;
    for (int i = 0; (field = fields[i]); i++) {
       const char* title = Process_fields[field].title;
-      if (!title) title = "- ";
+      if (!title) {
+         title = "- ";
+      }
+
       int len = strlen(title);
       if (at >= x && at <= x + len) {
          return field;
@@ -306,9 +327,10 @@ 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);
-      if (p->updated == false)
+      if (p->updated == false) {
          ProcessList_remove(this, p);
-      else
+      } else {
          p->updated = false;
       }
    }
+}

RichString.c

@@ -52,6 +52,7 @@ static inline void RichString_writeFrom(RichString* this, int attrs, const char*
    len = mbstowcs(data, data_c, len);
    if (len < 0)
       return;
+
    int newLen = from + len;
    RichString_setLen(this, newLen);
    for (int i = from, j = 0; i < newLen; i++, j++) {
@@ -84,8 +85,9 @@ int RichString_findChar(RichString* this, char c, int start) {
 static inline void RichString_writeFrom(RichString* this, int attrs, const char* data_c, int from, int len) {
    int newLen = from + len;
    RichString_setLen(this, newLen);
-   for (int i = from, j = 0; i < newLen; i++, j++)
+   for (int i = from, j = 0; i < newLen; i++, j++) {
       this->chptr[i] = (data_c[j] >= 32 ? data_c[j] : '?') | attrs;
+   }
    this->chptr[newLen] = 0;
 }
 

ScreenManager.c

@@ -103,8 +103,12 @@ static void checkRecalculation(ScreenManager* this, double* oldTime, int* sortTi
    gettimeofday(&tv, NULL);
    double newTime = ((double)tv.tv_sec * 10) + ((double)tv.tv_usec / 100000);
    *timedOut = (newTime - *oldTime > this->settings->delay);
-   *rescan = *rescan || *timedOut;
+   *rescan |= *timedOut;
-   if (newTime < *oldTime) *rescan = true; // clock was adjusted?
+
+   if (newTime < *oldTime) {
+      *rescan = true; // clock was adjusted?
+   }
+
    if (*rescan) {
       *oldTime = newTime;
       ProcessList_scan(pl, this->state->pauseProcessUpdate);
@@ -134,8 +138,9 @@ static void ScreenManager_drawPanels(ScreenManager* this, int focus) {
 
 static Panel* setCurrentPanel(const ScreenManager* this, Panel* panel) {
    FunctionBar_draw(panel->currentBar);
-   if (panel == this->state->panel && this->state->pauseProcessUpdate)
+   if (panel == this->state->panel && this->state->pauseProcessUpdate) {
       FunctionBar_append("PAUSED", CRT_colors[PAUSED]);
+   }
 
    return panel;
 }
@@ -218,8 +223,9 @@ void ScreenManager_run(ScreenManager* this, Panel** lastFocus, int* lastKey) {
             if (closeTimeout == 100) {
                break;
             }
-         } else
+         } else {
             closeTimeout = 0;
+         }
          redraw = false;
          continue;
       }
@@ -261,14 +267,21 @@ void ScreenManager_run(ScreenManager* this, Panel** lastFocus, int* lastKey) {
          if (this->panelCount < 2) {
             goto defaultHandler;
          }
-         if (!this->allowFocusChange)
+
+         if (!this->allowFocusChange) {
             break;
+         }
+
 tryLeft:
-         if (focus > 0)
+         if (focus > 0) {
             focus--;
+         }
+
          panelFocus = setCurrentPanel(this, (Panel*) Vector_get(this->panels, focus));
-         if (Panel_size(panelFocus) == 0 && focus > 0)
+         if (Panel_size(panelFocus) == 0 && focus > 0) {
             goto tryLeft;
+         }
+
          break;
       case KEY_RIGHT:
       case KEY_CTRL('F'):
@@ -276,14 +289,20 @@ void ScreenManager_run(ScreenManager* this, Panel** lastFocus, int* lastKey) {
          if (this->panelCount < 2) {
             goto defaultHandler;
          }
-         if (!this->allowFocusChange)
+         if (!this->allowFocusChange) {
             break;
+         }
+
 tryRight:
-         if (focus < this->panelCount - 1)
+         if (focus < this->panelCount - 1) {
             focus++;
+         }
+
          panelFocus = setCurrentPanel(this, (Panel*) Vector_get(this->panels, focus));
-         if (Panel_size(panelFocus) == 0 && focus < this->panelCount - 1)
+         if (Panel_size(panelFocus) == 0 && focus < this->panelCount - 1) {
             goto tryRight;
+         }
+
          break;
       case KEY_F(10):
       case 'q':
@@ -298,8 +317,11 @@ void ScreenManager_run(ScreenManager* this, Panel** lastFocus, int* lastKey) {
       }
    }
 
-   if (lastFocus)
+   if (lastFocus) {
       *lastFocus = panelFocus;
-   if (lastKey)
+   }
+
+   if (lastKey) {
       *lastKey = ch;
    }
+}

Settings.c

@@ -116,6 +116,7 @@ static bool Settings_read(Settings* this, const char* fileName, int initialCpuCo
    CRT_restorePrivileges();
    if (!fd)
       return false;
+
    bool didReadMeters = false;
    bool didReadFields = false;
    for (;;) {
@@ -182,8 +183,9 @@ static bool Settings_read(Settings* this, const char* fileName, int initialCpuCo
          this->delay = atoi(option[1]);
       } else if (String_eq(option[0], "color_scheme")) {
          this->colorScheme = atoi(option[1]);
-         if (this->colorScheme < 0 || this->colorScheme >= LAST_COLORSCHEME)
+         if (this->colorScheme < 0 || this->colorScheme >= LAST_COLORSCHEME) {
             this->colorScheme = 0;
+         }
       } else if (String_eq(option[0], "enable_mouse")) {
          this->enableMouse = atoi(option[1]);
       } else if (String_eq(option[0], "left_meters")) {
@@ -327,7 +329,9 @@ Settings* Settings_new(int initialCpuCount) {
       this->filename = xStrdup(rcfile);
    } else {
       const char* home = getenv("HOME");
-      if (!home) home = "";
+      if (!home)
+         home = "";
+
       const char* xdgConfigHome = getenv("XDG_CONFIG_HOME");
       char* configDir = NULL;
       char* htopDir = NULL;
@@ -363,9 +367,10 @@ Settings* Settings_new(int initialCpuCount) {
       ok = Settings_read(this, legacyDotfile, initialCpuCount);
       if (ok) {
          // Transition to new location and delete old configuration file
-         if (Settings_write(this))
+         if (Settings_write(this)) {
             unlink(legacyDotfile);
          }
+      }
       free(legacyDotfile);
    }
    if (!ok) {
@@ -389,8 +394,9 @@ Settings* Settings_new(int initialCpuCount) {
 }
 
 void Settings_invertSortOrder(Settings* this) {
-   if (this->direction == 1)
+   if (this->direction == 1) {
       this->direction = -1;
-   else
+   } else {
       this->direction = 1;
    }
+}

TraceScreen.c

@@ -61,8 +61,11 @@ void TraceScreen_delete(Object* cast) {
       kill(this->child, SIGTERM);
       waitpid(this->child, NULL, 0);
    }
-   if (this->strace)
+
+   if (this->strace) {
       fclose(this->strace);
+   }
+
    CRT_enableDelay();
    free(InfoScreen_done((InfoScreen*)this));
 }
@@ -144,9 +147,11 @@ void TraceScreen_updateTrace(InfoScreen* super) {
    tv.tv_sec = 0;
    tv.tv_usec = 500;
    int ready = select(fd_strace + 1, &fds, NULL, NULL, &tv);
+
    size_t nread = 0;
    if (ready > 0 && FD_ISSET(fd_strace, &fds))
       nread = fread(buffer, 1, sizeof(buffer) - 1, this->strace);
+
    if (nread && this->tracing) {
       const char* line = buffer;
       buffer[nread] = '\0';
@@ -167,10 +172,11 @@ void TraceScreen_updateTrace(InfoScreen* super) {
          buffer[nread] = '\0';
          this->contLine = true;
       }
-      if (this->follow)
+      if (this->follow) {
          Panel_setSelected(this->super.display, Panel_size(this->super.display) - 1);
       }
    }
+}
 
 bool TraceScreen_onKey(InfoScreen* super, int ch) {
    TraceScreen* this = (TraceScreen*) super;

Vector.c

@@ -17,8 +17,10 @@ in the source distribution for its full text.
 Vector* Vector_new(const ObjectClass* type, bool owner, int size) {
    Vector* this;
 
-   if (size == DEFAULT_SIZE)
+   if (size == DEFAULT_SIZE) {
       size = 10;
+   }
+
    assert(size > 0);
    this = xMalloc(sizeof(Vector));
    this->growthRate = size;
@@ -32,10 +34,12 @@ Vector* Vector_new(const ObjectClass* type, bool owner, int size) {
 
 void Vector_delete(Vector* this) {
    if (this->owner) {
-      for (int i = 0; i < this->items; i++)
+      for (int i = 0; i < this->items; i++) {
-         if (this->array[i])
+         if (this->array[i]) {
             Object_delete(this->array[i]);
          }
+      }
+   }
    free(this->array);
    free(this);
 }
@@ -45,9 +49,11 @@ void Vector_delete(Vector* this) {
 static bool Vector_isConsistent(const Vector* this) {
    assert(this->items <= this->arraySize);
    if (this->owner) {
-      for (int i = 0; i < this->items; i++)
+      for (int i = 0; i < this->items; i++) {
-         if (this->array[i] && !Object_isA(this->array[i], this->type))
+         if (this->array[i] && !Object_isA(this->array[i], this->type)) {
             return false;
+         }
+      }
       return true;
    } else {
       return true;
@@ -57,9 +63,10 @@ static bool Vector_isConsistent(const Vector* this) {
 int Vector_count(const Vector* this) {
    int items = 0;
    for (int i = 0; i < this->items; i++) {
-      if (this->array[i])
+      if (this->array[i]) {
          items++;
       }
+   }
    assert(items == this->items);
    return items;
 }
@@ -230,15 +237,18 @@ Object* Vector_remove(Vector* this, int idx) {
    if (this->owner) {
       Object_delete(removed);
       return NULL;
-   } else
+   } else {
       return removed;
    }
+}
 
 void Vector_moveUp(Vector* this, int idx) {
    assert(idx >= 0 && idx < this->items);
    assert(Vector_isConsistent(this));
+
    if (idx == 0)
       return;
+
    Object* temp = this->array[idx];
    this->array[idx] = this->array[idx - 1];
    this->array[idx - 1] = temp;
@@ -247,8 +257,10 @@ void Vector_moveUp(Vector* this, int idx) {
 void Vector_moveDown(Vector* this, int idx) {
    assert(idx >= 0 && idx < this->items);
    assert(Vector_isConsistent(this));
+
    if (idx == this->items - 1)
       return;
+
    Object* temp = this->array[idx];
    this->array[idx] = this->array[idx + 1];
    this->array[idx + 1] = temp;
@@ -307,9 +319,10 @@ int Vector_indexOf(const Vector* this, const void* search_, Object_Compare compa
    for (int i = 0; i < this->items; i++) {
       const Object* o = this->array[i];
       assert(o);
-      if (compare(search, o) == 0)
+      if (compare(search, o) == 0) {
          return i;
       }
+   }
    return -1;
 }
 
@@ -321,6 +334,7 @@ void Vector_splice(Vector* this, Vector* from) {
    int olditems = this->items;
    this->items += from->items;
    Vector_checkArraySize(this);
-   for (int j = 0; j < from->items; j++)
+   for (int j = 0; j < from->items; j++) {
       this->array[olditems + j] = from->array[j];
    }
+}

darwin/DarwinProcessList.c

@@ -110,15 +110,18 @@ struct kinfo_proc* ProcessList_getKInfoProcs(size_t* count) {
     * process entry or two.
     */
    *count = 0;
-   if (sysctl(mib, 4, NULL, count, NULL, 0) < 0)
+   if (sysctl(mib, 4, NULL, count, NULL, 0) < 0) {
       CRT_fatalError("Unable to get size of kproc_infos");
+   }
 
    processes = xMalloc(*count);
-   if (processes == NULL)
+   if (processes == NULL) {
       CRT_fatalError("Out of memory for kproc_infos");
+   }
 
-   if (sysctl(mib, 4, processes, count, NULL, 0) < 0)
+   if (sysctl(mib, 4, processes, count, NULL, 0) < 0) {
       CRT_fatalError("Unable to get kinfo_procs");
+   }
 
    *count = *count / sizeof(struct kinfo_proc);
 

dragonflybsd/Battery.c

@@ -14,15 +14,17 @@ in the source distribution for its full text.
 void Battery_getData(double* level, ACPresence* isOnAC) {
    int life;
    size_t life_len = sizeof(life);
-   if (sysctlbyname("hw.acpi.battery.life", &life, &life_len, NULL, 0) == -1)
+   if (sysctlbyname("hw.acpi.battery.life", &life, &life_len, NULL, 0) == -1) {
       *level = NAN;
-   else
+   } else {
       *level = life;
+   }
 
    int acline;
    size_t acline_len = sizeof(acline);
-   if (sysctlbyname("hw.acpi.acline", &acline, &acline_len, NULL, 0) == -1)
+   if (sysctlbyname("hw.acpi.acline", &acline, &acline_len, NULL, 0) == -1) {
       *isOnAC = AC_ERROR;
-   else
+   } else {
       *isOnAC = acline == 0 ? AC_ABSENT : AC_PRESENT;
    }
+}

dragonflybsd/DragonFlyBSDProcess.c

@@ -131,8 +131,9 @@ long DragonFlyBSDProcess_compare(const void* v1, const void* v2) {
 bool Process_isThread(const Process* this) {
    const DragonFlyBSDProcess* fp = (const DragonFlyBSDProcess*) this;
 
-   if (fp->kernel == 1 )
+   if (fp->kernel == 1 ) {
       return 1;
-   else
+   } else {
       return (Process_isUserlandThread(this));
    }
+}

dragonflybsd/DragonFlyBSDProcessList.c

@@ -123,7 +123,9 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidMatchList, ui
 
 void ProcessList_delete(ProcessList* this) {
    const DragonFlyBSDProcessList* dfpl = (DragonFlyBSDProcessList*) this;
-   if (dfpl->kd) kvm_close(dfpl->kd);
+   if (dfpl->kd) {
+      kvm_close(dfpl->kd);
+   }
 
    if (dfpl->jails) {
       Hashtable_delete(dfpl->jails);
@@ -199,7 +201,9 @@ static inline void DragonFlyBSDProcessList_scanCPUTime(ProcessList* pl) {
 
       // totals
       total_d = total_n - total_o;
-      if (total_d < 1 ) total_d = 1;
+      if (total_d < 1 ) {
+         total_d = 1;
+      }
 
       // save current state as old and calc percentages
       for (int s = 0; s < CPUSTATES; ++s) {
@@ -331,8 +335,9 @@ retry:
       int jailid;
       char* str_hostname;
       nextpos = strchr(curpos, '\n');
-      if (nextpos)
+      if (nextpos) {
          *nextpos++ = 0;
+      }
 
       jailid = atoi(strtok(curpos, " "));
       str_hostname = strtok(NULL, " ");
@@ -372,8 +377,9 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
    DragonFlyBSDProcessList_scanJails(dfpl);
 
    // in pause mode only gather global data for meters (CPU/memory/...)
-   if (pauseProcessUpdate)
+   if (pauseProcessUpdate) {
       return;
+   }
 
    int count = 0;
 

dragonflybsd/Platform.c

@@ -177,7 +177,9 @@ double Platform_setCPUValues(Meter* this, int cpu) {
    }
 
    percent = CLAMP(percent, 0.0, 100.0);
-   if (isnan(percent)) percent = 0.0;
+   if (isnan(percent)) {
+      percent = 0.0;
+   }
 
    v[CPU_METER_FREQUENCY] = NAN;
 

freebsd/Battery.c

@@ -13,15 +13,17 @@ in the source distribution for its full text.
 void Battery_getData(double* level, ACPresence* isOnAC) {
    int life;
    size_t life_len = sizeof(life);
-   if (sysctlbyname("hw.acpi.battery.life", &life, &life_len, NULL, 0) == -1)
+   if (sysctlbyname("hw.acpi.battery.life", &life, &life_len, NULL, 0) == -1) {
       *level = NAN;
-   else
+   } else {
       *level = life;
+   }
 
    int acline;
    size_t acline_len = sizeof(acline);
-   if (sysctlbyname("hw.acpi.acline", &acline, &acline_len, NULL, 0) == -1)
+   if (sysctlbyname("hw.acpi.acline", &acline, &acline_len, NULL, 0) == -1) {
       *isOnAC = AC_ERROR;
-   else
+   } else {
       *isOnAC = acline == 0 ? AC_ABSENT : AC_PRESENT;
    }
+}

freebsd/FreeBSDProcess.c

@@ -134,11 +134,12 @@ static long FreeBSDProcess_compare(const void* v1, const void* v2) {
 bool Process_isThread(const Process* this) {
    const FreeBSDProcess* fp = (const FreeBSDProcess*) this;
 
-   if (fp->kernel == 1 )
+   if (fp->kernel == 1 ) {
       return 1;
-   else
+   } else {
       return Process_isUserlandThread(this);
    }
+}
 
 const ProcessClass FreeBSDProcess_class = {
    .super = {

freebsd/FreeBSDProcessList.c

@@ -98,7 +98,9 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidMatchList, ui
 
    if (smp) {
       int err = sysctlbyname("kern.smp.cpus", &cpus, &len, NULL, 0);
-      if (err) cpus = 1;
+      if (err) {
+         cpus = 1;
+      }
    } else {
       cpus = 1;
    }
@@ -152,7 +154,9 @@ void ProcessList_delete(ProcessList* this) {
 
    Hashtable_delete(fpl->ttys);
 
-   if (fpl->kd) kvm_close(fpl->kd);
+   if (fpl->kd) {
+      kvm_close(fpl->kd);
+   }
 
    free(fpl->cp_time_o);
    free(fpl->cp_time_n);
@@ -225,7 +229,9 @@ static inline void FreeBSDProcessList_scanCPUTime(ProcessList* pl) {
 
       // totals
       total_d = total_n - total_o;
-      if (total_d < 1 ) total_d = 1;
+      if (total_d < 1 ) {
+         total_d = 1;
+      }
 
       // save current state as old and calc percentages
       for (int s = 0; s < CPUSTATES; ++s) {
@@ -434,13 +440,15 @@ IGNORE_WCASTQUAL_END
       jail_errmsg[0] = 0;
       jid = jail_get(jiov, 6, 0);
       if (jid < 0) {
-         if (!jail_errmsg[0])
+         if (!jail_errmsg[0]) {
             xSnprintf(jail_errmsg, JAIL_ERRMSGLEN, "jail_get: %s", strerror(errno));
+         }
          return NULL;
       } else if (jid == kproc->ki_jid) {
          jname = xStrdup(jnamebuf);
-         if (jname == NULL)
+         if (jname == NULL) {
             strerror_r(errno, jail_errmsg, JAIL_ERRMSGLEN);
+         }
          return jname;
       } else {
          return NULL;
@@ -464,11 +472,13 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
    FreeBSDProcessList_scanCPUTime(super);
 
    // in pause mode only gather global data for meters (CPU/memory/...)
-   if (pauseProcessUpdate)
+   if (pauseProcessUpdate) {
       return;
+   }
 
-   if (settings->flags & PROCESS_FLAG_FREEBSD_TTY)
+   if (settings->flags & PROCESS_FLAG_FREEBSD_TTY) {
       FreeBSDProcessList_scanTTYs(super);
+   }
 
    int count = 0;
    struct kinfo_proc* kprocs = kvm_getprocs(fpl->kd, KERN_PROC_PROC, 0, &count);
@@ -485,10 +495,11 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
       if (!preExisting) {
          fp->jid = kproc->ki_jid;
          proc->pid = kproc->ki_pid;
-         if ( ! ((kproc->ki_pid == 0) || (kproc->ki_pid == 1) ) && kproc->ki_flag & P_SYSTEM)
+         if ( ! ((kproc->ki_pid == 0) || (kproc->ki_pid == 1) ) && kproc->ki_flag & P_SYSTEM) {
             fp->kernel = 1;
-         else
+         } else {
             fp->kernel = 0;
+         }
          proc->ppid = kproc->ki_ppid;
          proc->tpgid = kproc->ki_tpgid;
          proc->tgid = kproc->ki_pid;
@@ -565,8 +576,9 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
       default:     proc->state = '?';
       }
 
-      if (settings->flags & PROCESS_FLAG_FREEBSD_TTY)
+      if (settings->flags & PROCESS_FLAG_FREEBSD_TTY) {
          fp->ttyPath = (kproc->ki_tdev == NODEV) ? nodevStr : Hashtable_get(fpl->ttys, kproc->ki_tdev);
+      }
 
       if (Process_isKernelThread(proc))
          super->kernelThreads++;

htop.c

@@ -243,12 +243,13 @@ static void setCommFilter(State* state, char** commFilter) {
 int main(int argc, char** argv) {
 
    char* lc_ctype = getenv("LC_CTYPE");
-   if (lc_ctype != NULL)
+   if (lc_ctype != NULL) {
       setlocale(LC_CTYPE, lc_ctype);
-   else if ((lc_ctype = getenv("LC_ALL")))
+   } else if ((lc_ctype = getenv("LC_ALL"))) {
       setlocale(LC_CTYPE, lc_ctype);
-   else
+   } else {
       setlocale(LC_CTYPE, "");
+   }
 
    CommandLineSettings flags = parseArguments(argc, argv); // may exit()
 
@@ -271,14 +272,18 @@ int main(int argc, char** argv) {
 
    Header_populateFromSettings(header);
 
-   if (flags.delay != -1)
+   if (flags.delay != -1) {
       settings->delay = flags.delay;
-   if (!flags.useColors)
+   }
+   if (!flags.useColors) {
       settings->colorScheme = COLORSCHEME_MONOCHROME;
-   if (!flags.enableMouse)
+   }
+   if (!flags.enableMouse) {
       settings->enableMouse = false;
-   if (flags.treeView)
+   }
+   if (flags.treeView) {
       settings->treeView = true;
+   }
 
    CRT_init(settings->delay, settings->colorScheme, flags.allowUnicode);
 

linux/Battery.c

@@ -52,9 +52,11 @@ static unsigned long int parseBatInfo(const char* fileName, const unsigned short
       struct dirent* dirEntry = readdir(batteryDir);
       if (!dirEntry)
          break;
+
       char* entryName = dirEntry->d_name;
       if (!String_startsWith(entryName, "BAT"))
          continue;
+
       batteries[nBatteries] = xStrdup(entryName);
       nBatteries++;
    }
@@ -74,12 +76,14 @@ static unsigned long int parseBatInfo(const char* fileName, const unsigned short
       for (unsigned short int j = 0; j < lineNum; j++) {
          free(line);
          line = String_readLine(file);
-         if (!line) break;
+         if (!line)
+            break;
       }
 
       fclose(file);
 
-      if (!line) break;
+      if (!line)
+         break;
 
       char* foundNumStr = String_getToken(line, wordNum);
       const unsigned long int foundNum = atoi(foundNumStr);
@@ -122,8 +126,11 @@ static ACPresence procAcpiCheck(void) {
          continue;
       }
       char* line = String_readLine(file);
+
       fclose(file);
-      if (!line) continue;
+
+      if (!line)
+         continue;
 
       char* isOnline = String_getToken(line, 2);
       free(line);
@@ -139,8 +146,10 @@ static ACPresence procAcpiCheck(void) {
       }
    }
 
-   if (dir)
+   if (dir) {
       closedir(dir);
+   }
+
    return isOn;
 }
 
@@ -170,14 +179,21 @@ static inline ssize_t xread(int fd, void* buf, size_t count) {
    size_t alreadyRead = 0;
    for (;;) {
       ssize_t res = read(fd, buf, count);
-      if (res == -1 && errno == EINTR) continue;
+      if (res == -1) {
+         if (errno == EINTR)
+            continue;
+         return -1;
+      }
+
       if (res > 0) {
          buf = ((char*)buf) + res;
          count -= res;
          alreadyRead += res;
       }
-      if (res == -1) return -1;
+
-      if (count == 0 || res == 0) return alreadyRead;
+      if (count == 0 || res == 0) {
+         return alreadyRead;
+      }
    }
 }
 
@@ -197,6 +213,7 @@ static void Battery_getSysData(double* level, ACPresence* isOnAC) {
       struct dirent* dirEntry = readdir(dir);
       if (!dirEntry)
          break;
+
       const char* entryName = dirEntry->d_name;
       char filePath[256];
 
@@ -257,14 +274,18 @@ static void Battery_getSysData(double* level, ACPresence* isOnAC) {
                fullSize = atoi(value);
                totalFull += fullSize;
                full = true;
-               if (now) break;
+               if (now) {
+                  break;
+               }
                continue;
             }
             value = (!now) ? match(energy, "NOW=") : NULL;
             if (value) {
                totalRemain += atoi(value);
                now = true;
-               if (full) break;
+               if (full) {
+                  break;
+               }
                continue;
             }
          }
@@ -288,7 +309,9 @@ static void Battery_getSysData(double* level, ACPresence* isOnAC) {
          char buffer[2] = "";
          for (;;) {
             ssize_t res = read(fd3, buffer, 1);
-            if (res == -1 && errno == EINTR) continue;
+            if (res == -1 && errno == EINTR) {
+               continue;
+            }
             break;
          }
          close(fd3);

linux/IOPriorityPanel.c

@@ -21,7 +21,11 @@ Panel* IOPriorityPanel_new(IOPriority currPrio) {
 
    Panel_setHeader(this, "IO Priority:");
    Panel_add(this, (Object*) ListItem_new("None (based on nice)", IOPriority_None));
-   if (currPrio == IOPriority_None) Panel_setSelected(this, 0);
+
+   if (currPrio == IOPriority_None) {
+      Panel_setSelected(this, 0);
+   }
+
    static const struct { int klass; const char* name; } classes[] = {
       { .klass = IOPRIO_CLASS_RT, .name = "Realtime" },
       { .klass = IOPRIO_CLASS_BE, .name = "Best-effort" },
@@ -33,11 +37,15 @@ Panel* IOPriorityPanel_new(IOPriority currPrio) {
          xSnprintf(name, sizeof(name) - 1, "%s %d %s", classes[c].name, i, i == 0 ? "(High)" : (i == 7 ? "(Low)" : ""));
          IOPriority ioprio = IOPriority_tuple(classes[c].klass, i);
          Panel_add(this, (Object*) ListItem_new(name, ioprio));
-         if (currPrio == ioprio) Panel_setSelected(this, Panel_size(this) - 1);
+         if (currPrio == ioprio) {
+            Panel_setSelected(this, Panel_size(this) - 1);
+         }
       }
    }
    Panel_add(this, (Object*) ListItem_new("Idle", IOPriority_Idle));
-   if (currPrio == IOPriority_Idle) Panel_setSelected(this, Panel_size(this) - 1);
+   if (currPrio == IOPriority_Idle) {
+      Panel_setSelected(this, Panel_size(this) - 1);
+   }
    return this;
 }
 

linux/LinuxProcess.c

@@ -168,8 +168,9 @@ dynamically  derived  from  the  cpu  nice level of the process:
 io_priority = (cpu_nice + 20) / 5. -- From ionice(1) man page
 */
 static int LinuxProcess_effectiveIOPriority(const LinuxProcess* this) {
-   if (IOPriority_class(this->ioPriority) == IOPRIO_CLASS_NONE)
+   if (IOPriority_class(this->ioPriority) == IOPRIO_CLASS_NONE) {
       return IOPriority_tuple(IOPRIO_CLASS_BE, (this->super.nice + 20) / 5);
+   }
 
    return this->ioPriority;
 }
@@ -290,8 +291,9 @@ void LinuxProcess_writeField(const Process* this, RichString* str, ProcessField
    case PERCENT_SWAP_DELAY: LinuxProcess_printDelay(lp->swapin_delay_percent, buffer, n); break;
    #endif
    case CTXT:
-      if (lp->ctxt_diff > 1000)
+      if (lp->ctxt_diff > 1000) {
          attr |= A_BOLD;
+      }
       xSnprintf(buffer, n, "%5lu ", lp->ctxt_diff);
       break;
    case SECATTR: snprintf(buffer, n, "%-30s   ", lp->secattr ? lp->secattr : "?"); break;

linux/LinuxProcessList.c

@@ -56,14 +56,21 @@ static ssize_t xread(int fd, void* buf, size_t count) {
    size_t alreadyRead = 0;
    for (;;) {
       ssize_t res = read(fd, buf, count);
-      if (res == -1 && errno == EINTR) continue;
+      if (res == -1) {
+         if (errno == EINTR)
+            continue;
+         return -1;
+      }
+
       if (res > 0) {
          buf = ((char*)buf) + res;
          count -= res;
          alreadyRead += res;
       }
-      if (res == -1) return -1;
+
-      if (count == 0 || res == 0) return alreadyRead;
+      if (count == 0 || res == 0) {
+         return alreadyRead;
+      }
    }
 }
 
@@ -78,6 +85,7 @@ static void LinuxProcessList_initTtyDrivers(LinuxProcessList* this) {
    int fd = open(PROCTTYDRIVERSFILE, O_RDONLY);
    if (fd == -1)
       return;
+
    char* buf = NULL;
    int bufSize = MAX_READ;
    int bufLen = 0;
@@ -160,21 +168,24 @@ static void LinuxProcessList_initNetlinkSocket(LinuxProcessList* this) {
 
 static int LinuxProcessList_computeCPUcount(void) {
    FILE* file = fopen(PROCSTATFILE, "r");
-   if (file == NULL)
+   if (file == NULL) {
       CRT_fatalError("Cannot open " PROCSTATFILE);
+   }
 
    int cpus = 0;
    char buffer[PROC_LINE_LENGTH + 1];
    while (fgets(buffer, sizeof(buffer), file)) {
-      if (String_startsWith(buffer, "cpu"))
+      if (String_startsWith(buffer, "cpu")) {
          cpus++;
       }
+   }
 
    fclose(file);
 
    /* subtract raw cpu entry */
-   if (cpus > 0)
+   if (cpus > 0) {
       cpus--;
+   }
 
    return cpus;
 }
@@ -218,16 +229,18 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidMatchList, ui
    // Read btime
    {
       FILE* statfile = fopen(PROCSTATFILE, "r");
-      if (statfile == NULL)
+      if (statfile == NULL) {
          CRT_fatalError("Cannot open " PROCSTATFILE);
+      }
 
       while (true) {
          char buffer[PROC_LINE_LENGTH + 1];
          if (fgets(buffer, sizeof(buffer), statfile) == NULL) {
             CRT_fatalError("No btime in " PROCSTATFILE);
          } else if (String_startsWith(buffer, "btime ")) {
-            if (sscanf(buffer, "btime %lld\n", &btime) != 1)
+            if (sscanf(buffer, "btime %lld\n", &btime) != 1) {
                CRT_fatalError("Failed to parse btime from " PROCSTATFILE);
+            }
             break;
          }
       }
@@ -298,16 +311,19 @@ static bool LinuxProcessList_readStatFile(Process* process, const char* dirname,
 
    int size = xread(fd, buf, MAX_READ);
    close(fd);
-   if (size <= 0) return false;
+   if (size <= 0)
+      return false;
    buf[size] = '\0';
 
    assert(process->pid == atoi(buf));
    char* location = strchr(buf, ' ');
-   if (!location) return false;
+   if (!location)
+      return false;
 
    location += 2;
    char* end = strrchr(location, ')');
-   if (!end) return false;
+   if (!end)
+      return false;
 
    int commsize = MINIMUM(end - location, commLenIn - 1);
    //  deepcode ignore BufferOverflow: commsize is bounded by the allocated length passed in by commLen, saved into commLenIn
@@ -359,8 +375,9 @@ static bool LinuxProcessList_readStatFile(Process* process, const char* dirname,
       location = strchr(location, ' ') + 1;
    }
    location += 1;
-   for (int i = 0; i < 15; i++)
+   for (int i = 0; i < 15; i++) {
       location = strchr(location, ' ') + 1;
+   }
    process->exit_signal = strtol(location, &location, 10);
    location += 1;
    assert(location != NULL);
@@ -411,7 +428,9 @@ static void LinuxProcessList_readIoFile(LinuxProcess* process, const char* dirna
    char buffer[1024];
    ssize_t buflen = xread(fd, buffer, 1023);
    close(fd);
-   if (buflen < 1) return;
+   if (buflen < 1)
+      return;
+
    buffer[buflen] = '\0';
    unsigned long long last_read = process->io_read_bytes;
    unsigned long long last_write = process->io_write_bytes;
@@ -464,6 +483,7 @@ static bool LinuxProcessList_readStatmFile(LinuxProcess* process, const char* di
    FILE* statmfile = fopen(filename, "r");
    if (!statmfile)
       return false;
+
    int r = fscanf(statmfile, "%ld %ld %ld %ld %ld %ld %ld",
                   &process->super.m_size,
                   &process->super.m_resident,
@@ -636,9 +656,13 @@ static void LinuxProcessList_readCGroupFile(LinuxProcess* process, const char* d
    while (!feof(file) && left > 0) {
       char buffer[PROC_LINE_LENGTH + 1];
       char* ok = fgets(buffer, PROC_LINE_LENGTH, file);
-      if (!ok) break;
+      if (!ok)
+         break;
+
       char* group = strchr(buffer, ':');
-      if (!group) break;
+      if (!group)
+         break;
+
       if (at != output) {
          *at = ';';
          at++;
@@ -662,6 +686,7 @@ static void LinuxProcessList_readVServerData(LinuxProcess* process, const char*
    FILE* file = fopen(filename, "r");
    if (!file)
       return;
+
    char buffer[PROC_LINE_LENGTH + 1];
    process->vxid = 0;
    while (fgets(buffer, PROC_LINE_LENGTH, file)) {
@@ -711,21 +736,24 @@ static void LinuxProcessList_readCtxtData(LinuxProcess* process, const char* dir
    FILE* file = fopen(filename, "r");
    if (!file)
       return;
+
    char buffer[PROC_LINE_LENGTH + 1];
    unsigned long ctxt = 0;
    while (fgets(buffer, PROC_LINE_LENGTH, file)) {
       if (String_startsWith(buffer, "voluntary_ctxt_switches:")) {
          unsigned long vctxt;
          int ok = sscanf(buffer, "voluntary_ctxt_switches:\t%lu", &vctxt);
-         if (ok >= 1)
+         if (ok >= 1) {
             ctxt += vctxt;
+         }
       } else if (String_startsWith(buffer, "nonvoluntary_ctxt_switches:")) {
          unsigned long nvctxt;
          int ok = sscanf(buffer, "nonvoluntary_ctxt_switches:\t%lu", &nvctxt);
-         if (ok >= 1)
+         if (ok >= 1) {
             ctxt += nvctxt;
          }
       }
+   }
    fclose(file);
    process->ctxt_diff = (ctxt > process->ctxt_total) ? (ctxt - process->ctxt_total) : 0;
    process->ctxt_total = ctxt;
@@ -749,10 +777,12 @@ static void LinuxProcessList_readSecattrData(LinuxProcess* process, const char*
       return;
    }
    char* newline = strchr(buffer, '\n');
-   if (newline)
+   if (newline) {
       *newline = '\0';
-   if (process->secattr && String_eq(process->secattr, buffer))
+   }
+   if (process->secattr && String_eq(process->secattr, buffer)) {
       return;
+   }
    free(process->secattr);
    process->secattr = xStrdup(buffer);
 }
@@ -905,17 +935,28 @@ static char* LinuxProcessList_updateTtyDevice(TtyDriver* ttyDrivers, unsigned in
       for (;;) {
          xAsprintf(&fullPath, "%s/%d", ttyDrivers[i].path, idx);
          int err = stat(fullPath, &sstat);
-         if (err == 0 && major(sstat.st_rdev) == maj && minor(sstat.st_rdev) == min) return fullPath;
+         if (err == 0 && major(sstat.st_rdev) == maj && minor(sstat.st_rdev) == min) {
+            return fullPath;
+         }
          free(fullPath);
+
          xAsprintf(&fullPath, "%s%d", ttyDrivers[i].path, idx);
          err = stat(fullPath, &sstat);
-         if (err == 0 && major(sstat.st_rdev) == maj && minor(sstat.st_rdev) == min) return fullPath;
+         if (err == 0 && major(sstat.st_rdev) == maj && minor(sstat.st_rdev) == min) {
+            return fullPath;
+         }
          free(fullPath);
-         if (idx == min) break;
+
+         if (idx == min) {
+            break;
+         }
+
          idx = min;
       }
       int err = stat(ttyDrivers[i].path, &sstat);
-      if (err == 0 && tty_nr == sstat.st_rdev) return xStrdup(ttyDrivers[i].path);
+      if (err == 0 && tty_nr == sstat.st_rdev) {
+         return xStrdup(ttyDrivers[i].path);
+      }
    }
    char* out;
    xAsprintf(&out, "/dev/%u:%u", maj, min);
@@ -933,7 +974,9 @@ static bool LinuxProcessList_recurseProcTree(LinuxProcessList* this, const char*
    #endif
 
    dir = opendir(dirname);
-   if (!dir) return false;
+   if (!dir)
+      return false;
+
    int cpus = pl->cpuCount;
    bool hideKernelThreads = settings->hideKernelThreads;
    bool hideUserlandThreads = settings->hideUserlandThreads;
@@ -1001,15 +1044,21 @@ static bool LinuxProcessList_recurseProcTree(LinuxProcessList* this, const char*
       unsigned int tty_nr = proc->tty_nr;
       if (! LinuxProcessList_readStatFile(proc, dirname, name, command, &commLen))
          goto errorReadingProcess;
+
       if (tty_nr != proc->tty_nr && this->ttyDrivers) {
          free(lp->ttyDevice);
          lp->ttyDevice = LinuxProcessList_updateTtyDevice(this->ttyDrivers, proc->tty_nr);
       }
-      if (settings->flags & PROCESS_FLAG_LINUX_IOPRIO)
+
+      if (settings->flags & PROCESS_FLAG_LINUX_IOPRIO) {
          LinuxProcess_updateIOPriority(lp);
+      }
+
       float percent_cpu = (lp->utime + lp->stime - lasttimes) / period * 100.0;
       proc->percent_cpu = CLAMP(percent_cpu, 0.0, cpus * 100.0);
-      if (isnan(proc->percent_cpu)) proc->percent_cpu = 0.0;
+      if (isnan(proc->percent_cpu))
+         proc->percent_cpu = 0.0;
+
       proc->percent_mem = (proc->m_resident * CRT_pageSizeKB) / (double)(pl->totalMem) * 100.0;
 
       if (!preExisting) {
@@ -1051,18 +1100,22 @@ static bool LinuxProcessList_recurseProcTree(LinuxProcessList* this, const char*
       #endif
 
       #ifdef HAVE_CGROUP
-      if (settings->flags & PROCESS_FLAG_LINUX_CGROUP)
+      if (settings->flags & PROCESS_FLAG_LINUX_CGROUP) {
          LinuxProcessList_readCGroupFile(lp, dirname, name);
+      }
       #endif
 
-      if (settings->flags & PROCESS_FLAG_LINUX_OOM)
+      if (settings->flags & PROCESS_FLAG_LINUX_OOM) {
          LinuxProcessList_readOomData(lp, dirname, name);
+      }
 
-      if (settings->flags & PROCESS_FLAG_LINUX_CTXT)
+      if (settings->flags & PROCESS_FLAG_LINUX_CTXT) {
          LinuxProcessList_readCtxtData(lp, dirname, name);
+      }
 
-      if (settings->flags & PROCESS_FLAG_LINUX_SECATTR)
+      if (settings->flags & PROCESS_FLAG_LINUX_SECATTR) {
          LinuxProcessList_readSecattrData(lp, dirname, name);
+      }
 
       if (proc->state == 'Z' && (proc->basenameOffset == 0)) {
          proc->basenameOffset = -1;
@@ -1072,9 +1125,10 @@ static bool LinuxProcessList_recurseProcTree(LinuxProcessList* this, const char*
             proc->basenameOffset = -1;
             setCommand(proc, command, commLen);
          } else if (settings->showThreadNames) {
-            if (! LinuxProcessList_readCmdlineFile(proc, dirname, name))
+            if (! LinuxProcessList_readCmdlineFile(proc, dirname, name)) {
                goto errorReadingProcess;
             }
+         }
          if (Process_isKernelThread(proc)) {
             pl->kernelThreads++;
          } else {
@@ -1293,10 +1347,13 @@ static inline double LinuxProcessList_scanCPUTime(LinuxProcessList* this) {
       // 5, 7, 8 or 9 of these fields will be set.
       // The rest will remain at zero.
       char* ok = fgets(buffer, PROC_LINE_LENGTH, file);
-      if (!ok) buffer[0] = '\0';
+      if (!ok) {
-      if (i == 0)
+         buffer[0] = '\0';
+      }
+
+      if (i == 0) {
          (void) sscanf(buffer,   "cpu  %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu",         &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest, &guestnice);
-      else {
+      } else {
          int cpuid;
          (void) sscanf(buffer, "cpu%4d %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu", &cpuid, &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest, &guestnice);
          assert(cpuid == i - 1);
@@ -1404,13 +1461,15 @@ static void scanCPUFreqencyFromCPUinfo(LinuxProcessList* this) {
          (sscanf(buffer, "cpu MHz : %lf", &frequency) == 1) ||
          (sscanf(buffer, "cpu MHz: %lf", &frequency) == 1)
       ) {
-         if (cpuid < 0 || cpuid > (cpus - 1))
+         if (cpuid < 0 || cpuid > (cpus - 1)) {
             continue;
+         }
 
          CPUData* cpuData = &(this->cpus[cpuid + 1]);
          /* do not override sysfs data */
-         if (isnan(cpuData->frequency))
+         if (isnan(cpuData->frequency)) {
             cpuData->frequency = frequency;
+         }
          numCPUsWithFrequency++;
          totalFrequency += frequency;
       } else if (buffer[0] == '\n') {
@@ -1419,19 +1478,22 @@ static void scanCPUFreqencyFromCPUinfo(LinuxProcessList* this) {
    }
    fclose(file);
 
-   if (numCPUsWithFrequency > 0)
+   if (numCPUsWithFrequency > 0) {
       this->cpus[0].frequency = totalFrequency / numCPUsWithFrequency;
    }
+}
 
 static void LinuxProcessList_scanCPUFrequency(LinuxProcessList* this) {
    int cpus = this->super.cpuCount;
    assert(cpus > 0);
 
-   for (int i = 0; i <= cpus; i++)
+   for (int i = 0; i <= cpus; i++) {
       this->cpus[i].frequency = NAN;
+   }
 
-   if (scanCPUFreqencyFromSysCPUFreq(this) == 0)
+   if (scanCPUFreqencyFromSysCPUFreq(this) == 0) {
       return;
+   }
 
    scanCPUFreqencyFromCPUinfo(this);
 }
@@ -1447,12 +1509,14 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
 
    double period = LinuxProcessList_scanCPUTime(this);
 
-   if (settings->showCPUFrequency)
+   if (settings->showCPUFrequency) {
       LinuxProcessList_scanCPUFrequency(this);
+   }
 
    // in pause mode only gather global data for meters (CPU/memory/...)
-   if (pauseProcessUpdate)
+   if (pauseProcessUpdate) {
       return;
+   }
 
    struct timeval tv;
    gettimeofday(&tv, NULL);

linux/Platform.c

@@ -98,16 +98,19 @@ static Htop_Reaction Platform_actionSetIOPriority(State* st) {
    Panel* panel = st->panel;
 
    LinuxProcess* p = (LinuxProcess*) Panel_getSelected(panel);
-   if (!p) return HTOP_OK;
+   if (!p)
+      return HTOP_OK;
+
    IOPriority ioprio1 = p->ioPriority;
    Panel* ioprioPanel = IOPriorityPanel_new(ioprio1);
    void* set = Action_pickFromVector(st, ioprioPanel, 21, true);
    if (set) {
       IOPriority ioprio2 = IOPriorityPanel_getIOPriority(ioprioPanel);
       bool ok = MainPanel_foreachProcess((MainPanel*)panel, LinuxProcess_setIOPriority, (Arg) { .i = ioprio2 }, NULL);
-      if (!ok)
+      if (!ok) {
          beep();
       }
+   }
    Panel_delete((Object*)ioprioPanel);
    return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
 }
@@ -162,7 +165,9 @@ int Platform_getUptime() {
    if (fd) {
       int n = fscanf(fd, "%64lf", &uptime);
       fclose(fd);
-      if (n <= 0) return 0;
+      if (n <= 0) {
+         return 0;
+      }
    }
    return floor(uptime);
 }
@@ -185,7 +190,9 @@ void Platform_getLoadAverage(double* one, double* five, double* fifteen) {
 
 int Platform_getMaxPid() {
    FILE* file = fopen(PROCDIR "/sys/kernel/pid_max", "r");
-   if (!file) return -1;
+   if (!file)
+      return -1;
+
    int maxPid = 4194303;
    int match = fscanf(file, "%32d", &maxPid);
    (void) match;
@@ -221,7 +228,9 @@ double Platform_setCPUValues(Meter* this, int cpu) {
       percent = v[0] + v[1] + v[2] + v[3];
    }
    percent = CLAMP(percent, 0.0, 100.0);
-   if (isnan(percent)) percent = 0.0;
+   if (isnan(percent)) {
+      percent = 0.0;
+   }
 
    v[CPU_METER_FREQUENCY] = cpuData->frequency;
 

linux/SELinuxMeter.c

@@ -32,16 +32,19 @@ static bool enforcing = false;
 static bool hasSELinuxMount(void) {
    struct statfs sfbuf;
    int r = statfs("/sys/fs/selinux", &sfbuf);
-   if (r != 0)
+   if (r != 0) {
       return false;
+   }
 
-   if (sfbuf.f_type != SELINUX_MAGIC)
+   if (sfbuf.f_type != SELINUX_MAGIC) {
       return false;
+   }
 
    struct statvfs vfsbuf;
    r = statvfs("/sys/fs/selinux", &vfsbuf);
-   if (r != 0 || (vfsbuf.f_flag & ST_RDONLY))
+   if (r != 0 || (vfsbuf.f_flag & ST_RDONLY)) {
       return false;
+   }
 
    return true;
 }
@@ -51,22 +54,26 @@ static bool isSelinuxEnabled(void) {
 }
 
 static bool isSelinuxEnforcing(void) {
-   if (!enabled)
+   if (!enabled) {
       return false;
+   }
 
    int fd = open("/sys/fs/selinux/enforce", O_RDONLY);
-   if (fd < 0)
+   if (fd < 0) {
       return false;
+   }
 
    char buf[20] = {0};
    int r = read(fd, buf, sizeof(buf) - 1);
    close(fd);
-   if (r < 0)
+   if (r < 0) {
       return false;
+   }
 
    int enforce = 0;
-   if (sscanf(buf, "%d", &enforce) != 1)
+   if (sscanf(buf, "%d", &enforce) != 1) {
       return false;
+   }
 
    return !!enforce;
 }

openbsd/OpenBSDProcessList.c

@@ -347,8 +347,9 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
    OpenBSDProcessList_scanCPUTime(opl);
 
    // in pause mode only gather global data for meters (CPU/memory/...)
-   if (pauseProcessUpdate)
+   if (pauseProcessUpdate) {
       return;
+   }
 
    OpenBSDProcessList_scanProcs(opl);
 }

openbsd/Platform.c

@@ -184,7 +184,9 @@ double Platform_setCPUValues(Meter* this, int cpu) {
    }
 
    totalPercent = CLAMP(totalPercent, 0.0, 100.0);
-   if (isnan(totalPercent)) totalPercent = 0.0;
+   if (isnan(totalPercent)) {
+      totalPercent = 0.0;
+   }
    return totalPercent;
 }
 
@@ -250,8 +252,9 @@ char* Platform_getProcessEnv(pid_t pid) {
    struct kinfo_proc* kproc;
    size_t capacity = 4096, size = 0;
 
-   if ((kt = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf)) == NULL)
+   if ((kt = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf)) == NULL) {
       return NULL;
+   }
 
    if ((kproc = kvm_getprocs(kt, KERN_PROC_PID, pid,
                              sizeof(struct kinfo_proc), &count)) == NULL) {

solaris/Platform.c

@@ -156,13 +156,19 @@ int Platform_getMaxPid() {
    kvar_t* ksvar = NULL;
    int vproc = 32778; // Reasonable Solaris default
    kc = kstat_open();
-   if (kc != NULL) { kshandle = kstat_lookup(kc,"unix",0,"var"); }
+   if (kc != NULL) {
-   if (kshandle != NULL) { kstat_read(kc,kshandle,NULL); }
+      kshandle = kstat_lookup(kc, "unix", 0, "var");
+   }
+   if (kshandle != NULL) {
+      kstat_read(kc, kshandle, NULL);
+   }
    ksvar = kshandle->ks_data;
    if (ksvar->v_proc > 0 ) {
       vproc = ksvar->v_proc;
    }
-   if (kc != NULL) { kstat_close(kc); }
+   if (kc != NULL) {
+      kstat_close(kc);
+   }
    return vproc;
 }
 
@@ -195,7 +201,9 @@ double Platform_setCPUValues(Meter* this, int cpu) {
    }
 
    percent = CLAMP(percent, 0.0, 100.0);
-   if (isnan(percent)) percent = 0.0;
+   if (isnan(percent)) {
+      percent = 0.0;
+   }
 
    v[CPU_METER_FREQUENCY] = NAN;
 
@@ -233,10 +241,12 @@ static int Platform_buildenv(void* accum, struct ps_prochandle* Phandle, uintptr
    (void) Phandle;
    (void) addr;
    size_t thissz = strlen(str);
-   if ((thissz + 2) > (accump->capacity - accump->size))
+   if ((thissz + 2) > (accump->capacity - accump->size)) {
       accump->env = xRealloc(accump->env, accump->capacity *= 2);
-   if ((thissz + 2) > (accump->capacity - accump->size))
+   }
+   if ((thissz + 2) > (accump->capacity - accump->size)) {
       return 1;
+   }
    strlcpy( accump->env + accump->size, str, (accump->capacity - accump->size));
    strncpy( accump->env + accump->size + thissz + 1, "\n", 1);
    accump->size = accump->size + thissz + 1;
@@ -249,8 +259,9 @@ char* Platform_getProcessEnv(pid_t pid) {
    int graberr;
    struct ps_prochandle* Phandle;
 
-   if ((Phandle = Pgrab(realpid, PGRAB_RDONLY, &graberr)) == NULL)
+   if ((Phandle = Pgrab(realpid, PGRAB_RDONLY, &graberr)) == NULL) {
       return "Unable to read process environment.";
+   }
 
    envBuilder.capacity = 4096;
    envBuilder.size     = 0;

solaris/SolarisProcessList.c

@@ -169,10 +169,11 @@ static inline void SolarisProcessList_scanMemoryInfo(ProcessList* pl) {
       pages          = kstat_data_lookup(meminfo, "pagestotal");
 
       pl->totalMem   = totalmem_pgs->value.ui64 * CRT_pageSizeKB;
-      if (pl->totalMem > freemem_pgs->value.ui64 * CRT_pageSizeKB)
+      if (pl->totalMem > freemem_pgs->value.ui64 * CRT_pageSizeKB) {
          pl->usedMem  = pl->totalMem - freemem_pgs->value.ui64 * CRT_pageSizeKB;
-      else
+      } else {
          pl->usedMem  = 0;   // This can happen in non-global zone (in theory)
+      }
       // Not sure how to implement this on Solaris - suggestions welcome!
       pl->cachedMem  = 0;
       // Not really "buffers" but the best Solaris analogue that I can find to
@@ -268,7 +269,9 @@ void ProcessList_delete(ProcessList* pl) {
    SolarisProcessList* spl = (SolarisProcessList*) pl;
    ProcessList_done(pl);
    free(spl->cpus);
-   if (spl->kd) kstat_close(spl->kd);
+   if (spl->kd) {
+      kstat_close(spl->kd);
+   }
    free(spl);
 }
 
@@ -287,7 +290,10 @@ int SolarisProcessList_walkproc(psinfo_t* _psinfo, lwpsinfo_t* _lwpsinfo, void*
    SolarisProcessList* spl = (SolarisProcessList*) listptr;
 
    id_t lwpid_real = _lwpsinfo->pr_lwpid;
-   if (lwpid_real > 1023) return 0;
+   if (lwpid_real > 1023) {
+      return 0;
+   }
+
    pid_t lwpid   = (_psinfo->pr_pid * 1024) + lwpid_real;
    bool onMasterLWP = (_lwpsinfo->pr_lwpid == _psinfo->pr_lwp.pr_lwpid);
    if (onMasterLWP) {
@@ -347,9 +353,13 @@ int SolarisProcessList_walkproc(psinfo_t* _psinfo, lwpsinfo_t* _lwpsinfo, void*
       if (sproc->kernel && !pl->settings->hideKernelThreads) {
          pl->kernelThreads += proc->nlwp;
          pl->totalTasks += proc->nlwp + 1;
-         if (proc->state == 'O') pl->runningTasks++;
+         if (proc->state == 'O') {
+            pl->runningTasks++;
+         }
       } else if (!sproc->kernel) {
-         if (proc->state == 'O') pl->runningTasks++;
+         if (proc->state == 'O') {
+            pl->runningTasks++;
+         }
          if (pl->settings->hideUserlandThreads) {
             pl->totalTasks++;
          } else {
@@ -403,8 +413,9 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
    SolarisProcessList_scanZfsArcstats(super);
 
    // in pause mode only gather global data for meters (CPU/memory/...)
-   if (pauseProcessUpdate)
+   if (pauseProcessUpdate) {
       return;
+   }
 
    super->kernelThreads = 1;
    proc_walk(&SolarisProcessList_walkproc, super, PR_WALK_LWP);

unsupported/UnsupportedProcessList.c

@@ -27,8 +27,9 @@ void ProcessList_delete(ProcessList* this) {
 void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
 
    // in pause mode only gather global data for meters (CPU/memory/...)
-   if (pauseProcessUpdate)
+   if (pauseProcessUpdate) {
       return;
+   }
 
    bool preExisting = true;
    Process* proc;