../src/basic/format-table.c

Bug Summary

File:	build-scan/../src/basic/format-table.c
Warning:	line 1189, column 40 Potential leak of memory pointed to by 'sorted'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name format-table.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -menable-no-infs -menable-no-nans -menable-unsafe-fp-math -fno-signed-zeros -mreassociate -freciprocal-math -fdenormal-fp-math=preserve-sign,preserve-sign -ffp-contract=fast -fno-rounding-math -ffast-math -ffinite-math-only -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/12.0.0 -include config.h -I src/basic/libbasic.a.p -I src/basic -I ../src/basic -I src/shared -I ../src/shared -I src/systemd -I ../src/systemd -I src/journal -I ../src/journal -I src/journal-remote -I ../src/journal-remote -I src/nspawn -I ../src/nspawn -I src/resolve -I ../src/resolve -I src/timesync -I ../src/timesync -I ../src/time-wait-sync -I src/login -I ../src/login -I src/udev -I ../src/udev -I src/libudev -I ../src/libudev -I src/core -I ../src/core -I ../src/libsystemd/sd-bus -I ../src/libsystemd/sd-device -I ../src/libsystemd/sd-hwdb -I ../src/libsystemd/sd-id128 -I ../src/libsystemd/sd-netlink -I ../src/libsystemd/sd-network -I src/libsystemd-network -I ../src/libsystemd-network -I . -I .. -I /usr/include/blkid -I /usr/include/libmount -D _FILE_OFFSET_BITS=64 -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wwrite-strings -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unused-result -Wno-format-signedness -Wno-error=nonnull -std=gnu99 -fconst-strings -fdebug-compilation-dir /home/mrc0mmand/repos/@redhat-plumbers/systemd-rhel8/build-scan -ferror-limit 19 -fvisibility default -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-07-16-221226-1465241-1 -x c ../src/basic/format-table.c

../src/basic/format-table.c

→

1/* SPDX-License-Identifier: LGPL-2.1+ */

3#include <ctype.h>
4#include <stdio_ext.h>

6#include "alloc-util.h"
7#include "fd-util.h"
8#include "fileio.h"
9#include "format-table.h"
10#include "gunicode.h"
11#include "pager.h"
12#include "parse-util.h"
13#include "string-util.h"
14#include "terminal-util.h"
15#include "time-util.h"
16#include "utf8.h"
17#include "util.h"

19#define DEFAULT_WEIGHT100 100

21/*
 A few notes on implementation details:

- TableCell is a 'fake' structure, it's just used as data type to pass references to specific cell positions in the
 table. It can be easily converted to an index number and back.

- TableData is where the actual data is stored: it encapsulates the data and formatting for a specific cell. It's
 'pseudo-immutable' and ref-counted. When a cell's data's formatting is to be changed, we duplicate the object if the
 ref-counting is larger than 1. Note that TableData and its ref-counting is mostly not visible to the outside. The
 outside only sees Table and TableCell.

- The Table object stores a simple one-dimensional array of references to TableData objects, one row after the
 previous one.

- There's no special concept of a "row" or "column" in the table, and no special concept of the "header" row. It's all
 derived from the cell index: we know how many cells are to be stored in a row, and can determine the rest from
 that. The first row is always the header row. If header display is turned off we simply skip outputting the first
 row. Also, when sorting rows we always leave the first row where it is, as the header shouldn't move.

- Note because there's no row and no column object some properties that might be approproate as row/column properties
 are exposed as cell properties instead. For example, the "weight" of a column (which is used to determine where to
 add/remove space preferable when expanding/compressing tables horizontally) is actually made the "weight" of a
 cell. Given that we usually need it per-column though we will calculate the average across every cell of the column
 instead.

- To make things easy, when cells are added without any explicit configured formatting, then we'll copy the formatting
 from the same cell in the previous cell. This is particularly useful for the "weight" of the cell (see above), as
 this means setting the weight of the cells of the header row will nicely propagate to all cells in the other rows.
49*/

51typedef struct TableData {
      unsigned n_ref;
      TableDataType type;

      size_t minimum_width;       /* minimum width for the column */
      size_t maximum_width;       /* maximum width for the column */
      unsigned weight;            /* the horizontal weight for this column, in case the table is expanded/compressed */
      unsigned ellipsize_percent; /* 0 … 100, where to place the ellipsis when compression is needed */
      unsigned align_percent;     /* 0 … 100, where to pad with spaces when expanding is needed. 0: left-aligned, 100: right-aligned */

      bool_Bool uppercase;             /* Uppercase string on display */

      const char *color;          /* ANSI color string to use for this cell. When written to terminal should not move cursor. Will automatically be reset after the cell */
      char *url;                  /* A URL to use for a clickable hyperlink */
      char *formatted;            /* A cached textual representation of the cell data, before ellipsation/alignment */

      union {
              uint8_t data[0];    /* data is generic array */
              bool_Bool boolean;
              usec_t timestamp;
              usec_t timespan;
              uint64_t size;
              char string[0];
              uint32_t uint32;
              uint64_t uint64;
              int percent;        /* we use 'int' as datatype for percent values in order to match the result of parse_percent() */
              /* … add more here as we start supporting more cell data types … */
      };
79} TableData;

81static size_t TABLE_CELL_TO_INDEX(TableCell *cell) {
      unsigned i;

      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 84
, __PRETTY_FUNCTION__); } while (0);

      i = PTR_TO_UINT(cell)((unsigned int) ((uintptr_t) (cell)));
      assert(i > 0)do { if ((__builtin_expect(!!(!(i > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("i > 0"), "../src/basic/format-table.c"
, 87, __PRETTY_FUNCTION__); } while (0);

      return i-1;
90}

92static TableCell* TABLE_INDEX_TO_CELL(size_t index) {
      assert(index != (size_t) -1)do { if ((__builtin_expect(!!(!(index != (size_t) -1)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("index != (size_t) -1"), "../src/basic/format-table.c"
, 93, __PRETTY_FUNCTION__); } while (0);
      return UINT_TO_PTR((unsigned) (index + 1))((void *) ((uintptr_t) ((unsigned) (index + 1))));
95}

97struct Table {
      size_t n_columns;
      size_t n_cells;

      bool_Bool header;   /* Whether to show the header row? */
      size_t width;  /* If != (size_t) -1 the width to format this table in */

      TableData **data;
      size_t n_allocated;

      size_t *display_map;  /* List of columns to show (by their index). It's fine if columns are listed multiple times or not at all */
      size_t n_display_map;

      size_t *sort_map;     /* The columns to order rows by, in order of preference. */
      size_t n_sort_map;

      bool_Bool *reverse_map;
114};

116Table *table_new_raw(size_t n_columns) {
      _cleanup_(table_unrefp)__attribute__((cleanup(table_unrefp))) Table *t = NULL((void*)0);

      assert(n_columns > 0)do { if ((__builtin_expect(!!(!(n_columns > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("n_columns > 0"), "../src/basic/format-table.c"
, 119, __PRETTY_FUNCTION__); } while (0);

      t = new(Table, 1)((Table*) malloc_multiply(sizeof(Table), (1)));
      if (!t)
              return NULL((void*)0);

      *t = (struct Table) {
              .n_columns = n_columns,
              .header = true1,
              .width = (size_t) -1,
      };

      return TAKE_PTR(t)({ typeof(t) _ptr_ = (t); (t) = ((void*)0); _ptr_; });
132}

134Table *table_new_internal(const char *first_header, ...) {
      _cleanup_(table_unrefp)__attribute__((cleanup(table_unrefp))) Table *t = NULL((void*)0);
      size_t n_columns = 1;
      const char *h;
      va_list ap;
      int r;

      assert(first_header)do { if ((__builtin_expect(!!(!(first_header)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("first_header"), "../src/basic/format-table.c"
, 141, __PRETTY_FUNCTION__); } while (0);

      va_start(ap, first_header)__builtin_va_start(ap, first_header);
      for (;;) {
              h = va_arg(ap, const char*)__builtin_va_arg(ap, const char*);
              if (!h)
                      break;

              n_columns++;
      }
      va_end(ap)__builtin_va_end(ap);

      t = table_new_raw(n_columns);
      if (!t)
              return NULL((void*)0);

      va_start(ap, first_header)__builtin_va_start(ap, first_header);
      for (h = first_header; h; h = va_arg(ap, const char*)__builtin_va_arg(ap, const char*)) {
              TableCell *cell;

              r = table_add_cell(t, &cell, TABLE_STRING, h);
              if (r < 0) {
                      va_end(ap)__builtin_va_end(ap);
                      return NULL((void*)0);
              }

              /* Make the table header uppercase */
              r = table_set_uppercase(t, cell, true1);
              if (r < 0) {
                      va_end(ap)__builtin_va_end(ap);
                      return NULL((void*)0);
              }
      }
      va_end(ap)__builtin_va_end(ap);

      assert(t->n_columns == t->n_cells)do { if ((__builtin_expect(!!(!(t->n_columns == t->n_cells
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("t->n_columns == t->n_cells"
), "../src/basic/format-table.c", 176, __PRETTY_FUNCTION__); }
 while (0);
      return TAKE_PTR(t)({ typeof(t) _ptr_ = (t); (t) = ((void*)0); _ptr_; });
178}

180static TableData *table_data_unref(TableData *d) {
      if (!d)
              return NULL((void*)0);

      assert(d->n_ref > 0)do { if ((__builtin_expect(!!(!(d->n_ref > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("d->n_ref > 0"), "../src/basic/format-table.c"
, 184, __PRETTY_FUNCTION__); } while (0);
      d->n_ref--;

      if (d->n_ref > 0)
              return NULL((void*)0);

      free(d->formatted);
      free(d->url);

      return mfree(d);
194}

196DEFINE_TRIVIAL_CLEANUP_FUNC(TableData*, table_data_unref)static inline void table_data_unrefp(TableData* *p) { if (*p)
 table_data_unref(*p); };

198static TableData *table_data_ref(TableData *d) {
      if (!d)
              return NULL((void*)0);

      assert(d->n_ref > 0)do { if ((__builtin_expect(!!(!(d->n_ref > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("d->n_ref > 0"), "../src/basic/format-table.c"
, 202, __PRETTY_FUNCTION__); } while (0);
      d->n_ref++;

      return d;
206}

208Table *table_unref(Table *t) {
      size_t i;

      if (!t)
              return NULL((void*)0);

      for (i = 0; i < t->n_cells; i++)
              table_data_unref(t->data[i]);

      free(t->data);
      free(t->display_map);
      free(t->sort_map);
      free(t->reverse_map);

      return mfree(t);
223}

225static size_t table_data_size(TableDataType type, const void *data) {

      switch (type) {

      case TABLE_EMPTY:
              return 0;

      case TABLE_STRING:
              return strlen(data) + 1;

      case TABLE_BOOLEAN:
              return sizeof(bool_Bool);

      case TABLE_TIMESTAMP:
      case TABLE_TIMESPAN:
              return sizeof(usec_t);

      case TABLE_SIZE:
      case TABLE_UINT64:
              return sizeof(uint64_t);

      case TABLE_UINT32:
              return sizeof(uint32_t);

      case TABLE_PERCENT:
              return sizeof(int);

      default:
              assert_not_reached("Uh? Unexpected cell type")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Uh? Unexpected cell type"), "../src/basic/format-table.c", 253
, __PRETTY_FUNCTION__); } while (0);
      }
255}

257static bool_Bool table_data_matches(
              TableData *d,
              TableDataType type,
              const void *data,
              size_t minimum_width,
              size_t maximum_width,
              unsigned weight,
              unsigned align_percent,
              unsigned ellipsize_percent) {

      size_t k, l;
      assert(d)do { if ((__builtin_expect(!!(!(d)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("d"), "../src/basic/format-table.c", 268
, __PRETTY_FUNCTION__); } while (0);

      if (d->type != type)
              return false0;

      if (d->minimum_width != minimum_width)
              return false0;

      if (d->maximum_width != maximum_width)
              return false0;

      if (d->weight != weight)
              return false0;

      if (d->align_percent != align_percent)
              return false0;

      if (d->ellipsize_percent != ellipsize_percent)
              return false0;

      /* If a color/url/uppercase flag is set, refuse to merge */
      if (d->color)
              return false0;
      if (d->url)
              return false0;
      if (d->uppercase)
              return false0;

      k = table_data_size(type, data);
      l = table_data_size(d->type, d->data);

      if (k != l)
              return false0;

      return memcmp_safe(data, d->data, l) == 0;
303}

305static TableData *table_data_new(
              TableDataType type,
              const void *data,
              size_t minimum_width,
              size_t maximum_width,
              unsigned weight,
              unsigned align_percent,
              unsigned ellipsize_percent) {

      size_t data_size;
      TableData *d;

      data_size = table_data_size(type, data);

      d = malloc0(offsetof(TableData, data) + data_size)(calloc(1, (__builtin_offsetof(TableData, data) + data_size))
);
      if (!d)
              return NULL((void*)0);

      d->n_ref = 1;
      d->type = type;
      d->minimum_width = minimum_width;
      d->maximum_width = maximum_width;
      d->weight = weight;
      d->align_percent = align_percent;
      d->ellipsize_percent = ellipsize_percent;
      memcpy_safe(d->data, data, data_size);

      return d;
333}

335int table_add_cell_full(
              Table *t,
              TableCell **ret_cell,
              TableDataType type,
              const void *data,
              size_t minimum_width,
              size_t maximum_width,
              unsigned weight,
              unsigned align_percent,
              unsigned ellipsize_percent) {

      _cleanup_(table_data_unrefp)__attribute__((cleanup(table_data_unrefp))) TableData *d = NULL((void*)0);
      TableData *p;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 349
, __PRETTY_FUNCTION__); } while (0);
      assert(type >= 0)do { if ((__builtin_expect(!!(!(type >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("type >= 0"), "../src/basic/format-table.c"
, 350, __PRETTY_FUNCTION__); } while (0);
      assert(type < _TABLE_DATA_TYPE_MAX)do { if ((__builtin_expect(!!(!(type < _TABLE_DATA_TYPE_MAX
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("type < _TABLE_DATA_TYPE_MAX"
), "../src/basic/format-table.c", 351, __PRETTY_FUNCTION__); }
 while (0);

      /* Determine the cell adjacent to the current one, but one row up */
      if (t->n_cells >= t->n_columns)
              assert_se(p = t->data[t->n_cells - t->n_columns])do { if ((__builtin_expect(!!(!(p = t->data[t->n_cells -
 t->n_columns])),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("p = t->data[t->n_cells - t->n_columns]"), "../src/basic/format-table.c"
, 355, __PRETTY_FUNCTION__); } while (0);
      else
              p = NULL((void*)0);

      /* If formatting parameters are left unspecified, copy from the previous row */
      if (minimum_width == (size_t) -1)
              minimum_width = p ? p->minimum_width : 1;

      if (weight == (unsigned) -1)
              weight = p ? p->weight : DEFAULT_WEIGHT100;

      if (align_percent == (unsigned) -1)
              align_percent = p ? p->align_percent : 0;

      if (ellipsize_percent == (unsigned) -1)
              ellipsize_percent = p ? p->ellipsize_percent : 100;

      assert(align_percent <= 100)do { if ((__builtin_expect(!!(!(align_percent <= 100)),0))
) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("align_percent <= 100"
), "../src/basic/format-table.c", 372, __PRETTY_FUNCTION__); }
 while (0);
      assert(ellipsize_percent <= 100)do { if ((__builtin_expect(!!(!(ellipsize_percent <= 100))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("ellipsize_percent <= 100"
), "../src/basic/format-table.c", 373, __PRETTY_FUNCTION__); }
 while (0);

      /* Small optimization: Pretty often adjacent cells in two subsequent lines have the same data and
       * formatting. Let's see if we can reuse the cell data and ref it once more. */

      if (p && table_data_matches(p, type, data, minimum_width, maximum_width, weight, align_percent, ellipsize_percent))
              d = table_data_ref(p);
      else {
              d = table_data_new(type, data, minimum_width, maximum_width, weight, align_percent, ellipsize_percent);
              if (!d)
                      return -ENOMEM12;
      }

      if (!GREEDY_REALLOC(t->data, t->n_allocated, MAX(t->n_cells + 1, t->n_columns))greedy_realloc((void**) &(t->data), &(t->n_allocated
), (__extension__ ({ const typeof((t->n_cells + 1)) __unique_prefix_A106
 = ((t->n_cells + 1)); const typeof((t->n_columns)) __unique_prefix_B107
 = ((t->n_columns)); __unique_prefix_A106 > __unique_prefix_B107
 ? __unique_prefix_A106 : __unique_prefix_B107; })), sizeof((
t->data)[0])))
              return -ENOMEM12;

      if (ret_cell)
              *ret_cell = TABLE_INDEX_TO_CELL(t->n_cells);

      t->data[t->n_cells++] = TAKE_PTR(d)({ typeof(d) _ptr_ = (d); (d) = ((void*)0); _ptr_; });

      return 0;
395}

397int table_dup_cell(Table *t, TableCell *cell) {
      size_t i;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 400
, __PRETTY_FUNCTION__); } while (0);

      /* Add the data of the specified cell a second time as a new cell to the end. */

      i = TABLE_CELL_TO_INDEX(cell);
      if (i >= t->n_cells)
              return -ENXIO6;

      if (!GREEDY_REALLOC(t->data, t->n_allocated, MAX(t->n_cells + 1, t->n_columns))greedy_realloc((void**) &(t->data), &(t->n_allocated
), (__extension__ ({ const typeof((t->n_cells + 1)) __unique_prefix_A108
 = ((t->n_cells + 1)); const typeof((t->n_columns)) __unique_prefix_B109
 = ((t->n_columns)); __unique_prefix_A108 > __unique_prefix_B109
 ? __unique_prefix_A108 : __unique_prefix_B109; })), sizeof((
t->data)[0])))
              return -ENOMEM12;

      t->data[t->n_cells++] = table_data_ref(t->data[i]);
      return 0;
413}

415static int table_dedup_cell(Table *t, TableCell *cell) {
      _cleanup_free___attribute__((cleanup(freep))) char *curl = NULL((void*)0);
      TableData *nd, *od;
      size_t i;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 420
, __PRETTY_FUNCTION__); } while (0);

      /* Helper call that ensures the specified cell's data object has a ref count of 1, which we can use before
       * changing a cell's formatting without effecting every other cell's formatting that shares the same data */

      i = TABLE_CELL_TO_INDEX(cell);
      if (i >= t->n_cells)
              return -ENXIO6;

      assert_se(od = t->data[i])do { if ((__builtin_expect(!!(!(od = t->data[i])),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("od = t->data[i]"), "../src/basic/format-table.c"
, 429, __PRETTY_FUNCTION__); } while (0);
      if (od->n_ref == 1)
              return 0;

      assert(od->n_ref > 1)do { if ((__builtin_expect(!!(!(od->n_ref > 1)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("od->n_ref > 1"), "../src/basic/format-table.c"
, 433, __PRETTY_FUNCTION__); } while (0);

      if (od->url) {
              curl = strdup(od->url);
              if (!curl)
                      return -ENOMEM12;
      }

      nd = table_data_new(
                      od->type,
                      od->data,
                      od->minimum_width,
                      od->maximum_width,
                      od->weight,
                      od->align_percent,
                      od->ellipsize_percent);
      if (!nd)
              return -ENOMEM12;

      nd->color = od->color;
      nd->url = TAKE_PTR(curl)({ typeof(curl) _ptr_ = (curl); (curl) = ((void*)0); _ptr_; }
);
      nd->uppercase = od->uppercase;

      table_data_unref(od);
      t->data[i] = nd;

      assert(nd->n_ref == 1)do { if ((__builtin_expect(!!(!(nd->n_ref == 1)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("nd->n_ref == 1"), "../src/basic/format-table.c"
, 459, __PRETTY_FUNCTION__); } while (0);

      return 1;
462}

464static TableData *table_get_data(Table *t, TableCell *cell) {
      size_t i;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 467
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 468
, __PRETTY_FUNCTION__); } while (0);

      /* Get the data object of the specified cell, or NULL if it doesn't exist */

      i = TABLE_CELL_TO_INDEX(cell);
      if (i >= t->n_cells)
              return NULL((void*)0);

      assert(t->data[i])do { if ((__builtin_expect(!!(!(t->data[i])),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t->data[i]"), "../src/basic/format-table.c"
, 476, __PRETTY_FUNCTION__); } while (0);
      assert(t->data[i]->n_ref > 0)do { if ((__builtin_expect(!!(!(t->data[i]->n_ref > 0
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("t->data[i]->n_ref > 0"
), "../src/basic/format-table.c", 477, __PRETTY_FUNCTION__); }
 while (0);

      return t->data[i];
480}

482int table_set_minimum_width(Table *t, TableCell *cell, size_t minimum_width) {
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 485
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 486
, __PRETTY_FUNCTION__); } while (0);

      if (minimum_width == (size_t) -1)
              minimum_width = 1;

      r = table_dedup_cell(t, cell);
      if (r < 0)
              return r;

      table_get_data(t, cell)->minimum_width = minimum_width;
      return 0;
497}

499int table_set_maximum_width(Table *t, TableCell *cell, size_t maximum_width) {
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 502
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 503
, __PRETTY_FUNCTION__); } while (0);

      r = table_dedup_cell(t, cell);
      if (r < 0)
              return r;

      table_get_data(t, cell)->maximum_width = maximum_width;
      return 0;
511}

513int table_set_weight(Table *t, TableCell *cell, unsigned weight) {
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 516
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 517
, __PRETTY_FUNCTION__); } while (0);

      if (weight == (unsigned) -1)
              weight = DEFAULT_WEIGHT100;

      r = table_dedup_cell(t, cell);
      if (r < 0)
              return r;

      table_get_data(t, cell)->weight = weight;
      return 0;
528}

530int table_set_align_percent(Table *t, TableCell *cell, unsigned percent) {
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 533
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 534
, __PRETTY_FUNCTION__); } while (0);

      if (percent == (unsigned) -1)
              percent = 0;

      assert(percent <= 100)do { if ((__builtin_expect(!!(!(percent <= 100)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("percent <= 100"), "../src/basic/format-table.c"
, 539, __PRETTY_FUNCTION__); } while (0);

      r = table_dedup_cell(t, cell);
      if (r < 0)
              return r;

      table_get_data(t, cell)->align_percent = percent;
      return 0;
547}

549int table_set_ellipsize_percent(Table *t, TableCell *cell, unsigned percent) {
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 552
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 553
, __PRETTY_FUNCTION__); } while (0);

      if (percent == (unsigned) -1)
              percent = 100;

      assert(percent <= 100)do { if ((__builtin_expect(!!(!(percent <= 100)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("percent <= 100"), "../src/basic/format-table.c"
, 558, __PRETTY_FUNCTION__); } while (0);

      r = table_dedup_cell(t, cell);
      if (r < 0)
              return r;

      table_get_data(t, cell)->ellipsize_percent = percent;
      return 0;
566}

568int table_set_color(Table *t, TableCell *cell, const char *color) {
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 571
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 572
, __PRETTY_FUNCTION__); } while (0);

      r = table_dedup_cell(t, cell);
      if (r < 0)
              return r;

      table_get_data(t, cell)->color = empty_to_null(color);
      return 0;
580}

582int table_set_url(Table *t, TableCell *cell, const char *url) {
      _cleanup_free___attribute__((cleanup(freep))) char *copy = NULL((void*)0);
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 586
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 587
, __PRETTY_FUNCTION__); } while (0);

      if (url) {
              copy = strdup(url);
              if (!copy)
                      return -ENOMEM12;
      }

      r = table_dedup_cell(t, cell);
      if (r < 0)
              return r;

      return free_and_replace(table_get_data(t, cell)->url, copy)({ free(table_get_data(t, cell)->url); (table_get_data(t, cell
)->url) = (copy); (copy) = ((void*)0); 0; });
600}

602int table_set_uppercase(Table *t, TableCell *cell, bool_Bool b) {
      TableData *d;
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 606
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 607
, __PRETTY_FUNCTION__); } while (0);

      r = table_dedup_cell(t, cell);
      if (r < 0)
              return r;

      assert_se(d = table_get_data(t, cell))do { if ((__builtin_expect(!!(!(d = table_get_data(t, cell)))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("d = table_get_data(t, cell)"
), "../src/basic/format-table.c", 613, __PRETTY_FUNCTION__); }
 while (0);

      if (d->uppercase == b)
              return 0;

      d->formatted = mfree(d->formatted);
      d->uppercase = b;
      return 1;
621}

623int table_update(Table *t, TableCell *cell, TableDataType type, const void *data) {
      _cleanup_free___attribute__((cleanup(freep))) char *curl = NULL((void*)0);
      TableData *nd, *od;
      size_t i;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 628
, __PRETTY_FUNCTION__); } while (0);
      assert(cell)do { if ((__builtin_expect(!!(!(cell)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cell"), "../src/basic/format-table.c", 629
, __PRETTY_FUNCTION__); } while (0);

      i = TABLE_CELL_TO_INDEX(cell);
      if (i >= t->n_cells)
              return -ENXIO6;

      assert_se(od = t->data[i])do { if ((__builtin_expect(!!(!(od = t->data[i])),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("od = t->data[i]"), "../src/basic/format-table.c"
, 635, __PRETTY_FUNCTION__); } while (0);

      if (od->url) {
              curl = strdup(od->url);
              if (!curl)
                      return -ENOMEM12;
      }

      nd = table_data_new(
                      type,
                      data,
                      od->minimum_width,
                      od->maximum_width,
                      od->weight,
                      od->align_percent,
                      od->ellipsize_percent);
      if (!nd)
              return -ENOMEM12;

      nd->color = od->color;
      nd->url = TAKE_PTR(curl)({ typeof(curl) _ptr_ = (curl); (curl) = ((void*)0); _ptr_; }
);
      nd->uppercase = od->uppercase;

      table_data_unref(od);
      t->data[i] = nd;

      return 0;
662}

664int table_add_many_internal(Table *t, TableDataType first_type, ...) {
      TableDataType type;
      va_list ap;
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 669
, __PRETTY_FUNCTION__); } while (0);
      assert(first_type >= 0)do { if ((__builtin_expect(!!(!(first_type >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("first_type >= 0"), "../src/basic/format-table.c"
, 670, __PRETTY_FUNCTION__); } while (0);
      assert(first_type < _TABLE_DATA_TYPE_MAX)do { if ((__builtin_expect(!!(!(first_type < _TABLE_DATA_TYPE_MAX
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("first_type < _TABLE_DATA_TYPE_MAX"
), "../src/basic/format-table.c", 671, __PRETTY_FUNCTION__); }
 while (0);

      type = first_type;

      va_start(ap, first_type)__builtin_va_start(ap, first_type);
      for (;;) {
              const void *data;
              union {
                      uint64_t size;
                      usec_t usec;
                      uint32_t uint32;
                      uint64_t uint64;
                      int percent;
                      bool_Bool b;
              } buffer;

              switch (type) {

              case TABLE_EMPTY:
                      data = NULL((void*)0);
                      break;

              case TABLE_STRING:
                      data = va_arg(ap, const char *)__builtin_va_arg(ap, const char *);
                      break;

              case TABLE_BOOLEAN:
                      buffer.b = va_arg(ap, int)__builtin_va_arg(ap, int);
                      data = &buffer.b;
                      break;

              case TABLE_TIMESTAMP:
              case TABLE_TIMESPAN:
                      buffer.usec = va_arg(ap, usec_t)__builtin_va_arg(ap, usec_t);
                      data = &buffer.usec;
                      break;

              case TABLE_SIZE:
                      buffer.size = va_arg(ap, uint64_t)__builtin_va_arg(ap, uint64_t);
                      data = &buffer.size;
                      break;

              case TABLE_UINT32:
                      buffer.uint32 = va_arg(ap, uint32_t)__builtin_va_arg(ap, uint32_t);
                      data = &buffer.uint32;
                      break;

              case TABLE_UINT64:
                      buffer.uint64 = va_arg(ap, uint64_t)__builtin_va_arg(ap, uint64_t);
                      data = &buffer.uint64;
                      break;

              case TABLE_PERCENT:
                      buffer.percent = va_arg(ap, int)__builtin_va_arg(ap, int);
                      data = &buffer.percent;
                      break;

              case _TABLE_DATA_TYPE_MAX:
                      /* Used as end marker */
                      va_end(ap)__builtin_va_end(ap);
                      return 0;

              default:
                      assert_not_reached("Uh? Unexpected data type.")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Uh? Unexpected data type."), "../src/basic/format-table.c", 734
, __PRETTY_FUNCTION__); } while (0);
              }

              r = table_add_cell(t, NULL((void*)0), type, data);
              if (r < 0) {
                      va_end(ap)__builtin_va_end(ap);
                      return r;
              }

              type = va_arg(ap, TableDataType)__builtin_va_arg(ap, TableDataType);
      }
745}

747void table_set_header(Table *t, bool_Bool b) {
      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 748
, __PRETTY_FUNCTION__); } while (0);

      t->header = b;
751}

753void table_set_width(Table *t, size_t width) {
      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 754
, __PRETTY_FUNCTION__); } while (0);

      t->width = width;
757}

759int table_set_display(Table *t, size_t first_column, ...) {
      size_t allocated, column;
      va_list ap;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 763
, __PRETTY_FUNCTION__); } while (0);

      allocated = t->n_display_map;
      column = first_column;

      va_start(ap, first_column)__builtin_va_start(ap, first_column);
      for (;;) {
              assert(column < t->n_columns)do { if ((__builtin_expect(!!(!(column < t->n_columns))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("column < t->n_columns"
), "../src/basic/format-table.c", 770, __PRETTY_FUNCTION__); }
 while (0);

              if (!GREEDY_REALLOC(t->display_map, allocated, MAX(t->n_columns, t->n_display_map+1))greedy_realloc((void**) &(t->display_map), &(allocated
), (__extension__ ({ const typeof((t->n_columns)) __unique_prefix_A110
 = ((t->n_columns)); const typeof((t->n_display_map+1))
 __unique_prefix_B111 = ((t->n_display_map+1)); __unique_prefix_A110
 > __unique_prefix_B111 ? __unique_prefix_A110 : __unique_prefix_B111
; })), sizeof((t->display_map)[0]))) {
                      va_end(ap)__builtin_va_end(ap);
                      return -ENOMEM12;
              }

              t->display_map[t->n_display_map++] = column;

              column = va_arg(ap, size_t)__builtin_va_arg(ap, size_t);
              if (column == (size_t) -1)
                      break;

      }
      va_end(ap)__builtin_va_end(ap);

      return 0;
787}

789int table_set_sort(Table *t, size_t first_column, ...) {
      size_t allocated, column;
      va_list ap;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 793
, __PRETTY_FUNCTION__); } while (0);

      allocated = t->n_sort_map;
      column = first_column;

      va_start(ap, first_column)__builtin_va_start(ap, first_column);
      for (;;) {
              assert(column < t->n_columns)do { if ((__builtin_expect(!!(!(column < t->n_columns))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("column < t->n_columns"
), "../src/basic/format-table.c", 800, __PRETTY_FUNCTION__); }
 while (0);

              if (!GREEDY_REALLOC(t->sort_map, allocated, MAX(t->n_columns, t->n_sort_map+1))greedy_realloc((void**) &(t->sort_map), &(allocated
), (__extension__ ({ const typeof((t->n_columns)) __unique_prefix_A112
 = ((t->n_columns)); const typeof((t->n_sort_map+1)) __unique_prefix_B113
 = ((t->n_sort_map+1)); __unique_prefix_A112 > __unique_prefix_B113
 ? __unique_prefix_A112 : __unique_prefix_B113; })), sizeof((
t->sort_map)[0]))) {
                      va_end(ap)__builtin_va_end(ap);
                      return -ENOMEM12;
              }

              t->sort_map[t->n_sort_map++] = column;

              column = va_arg(ap, size_t)__builtin_va_arg(ap, size_t);
              if (column == (size_t) -1)
                      break;
      }
      va_end(ap)__builtin_va_end(ap);

      return 0;
816}

818static int cell_data_compare(TableData *a, size_t index_a, TableData *b, size_t index_b) {
      assert(a)do { if ((__builtin_expect(!!(!(a)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("a"), "../src/basic/format-table.c", 819
, __PRETTY_FUNCTION__); } while (0);
      assert(b)do { if ((__builtin_expect(!!(!(b)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("b"), "../src/basic/format-table.c", 820
, __PRETTY_FUNCTION__); } while (0);

      if (a->type == b->type) {

              /* We only define ordering for cells of the same data type. If cells with different data types are
               * compared we follow the order the cells were originally added in */

              switch (a->type) {

              case TABLE_STRING:
                      return strcmp(a->string, b->string);

              case TABLE_BOOLEAN:
                      if (!a->boolean && b->boolean)
                              return -1;
                      if (a->boolean && !b->boolean)
                              return 1;
                      return 0;

              case TABLE_TIMESTAMP:
                      if (a->timestamp < b->timestamp)
                              return -1;
                      if (a->timestamp > b->timestamp)
                              return 1;
                      return 0;

              case TABLE_TIMESPAN:
                      if (a->timespan < b->timespan)
                              return -1;
                      if (a->timespan > b->timespan)
                              return 1;
                      return 0;

              case TABLE_SIZE:
                      if (a->size < b->size)
                              return -1;
                      if (a->size > b->size)
                              return 1;
                      return 0;

              case TABLE_UINT32:
                      if (a->uint32 < b->uint32)
                              return -1;
                      if (a->uint32 > b->uint32)
                              return 1;
                      return 0;

              case TABLE_UINT64:
                      return CMP(a->uint64, b->uint64)({ const typeof((a->uint64)) __unique_prefix_A114 = ((a->
uint64)); const typeof((b->uint64)) __unique_prefix_B115 =
 ((b->uint64)); __unique_prefix_A114 < __unique_prefix_B115
 ? -1 : __unique_prefix_A114 > __unique_prefix_B115 ? 1 : 0
; });

              case TABLE_PERCENT:
                      return CMP(a->percent, b->percent)({ const typeof((a->percent)) __unique_prefix_A116 = ((a->
percent)); const typeof((b->percent)) __unique_prefix_B117
 = ((b->percent)); __unique_prefix_A116 < __unique_prefix_B117
 ? -1 : __unique_prefix_A116 > __unique_prefix_B117 ? 1 : 0
; });

              default:
                      ;
              }
      }

      /* Generic fallback using the orginal order in which the cells where added. */
      if (index_a < index_b)
              return -1;
      if (index_a > index_b)
              return 1;

      return 0;
885}

887static int table_data_compare(const void *x, const void *y, void *userdata) {
      const size_t *a = x, *b = y;
      Table *t = userdata;
      size_t i;
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 893
, __PRETTY_FUNCTION__); } while (0);
      assert(t->sort_map)do { if ((__builtin_expect(!!(!(t->sort_map)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t->sort_map"), "../src/basic/format-table.c"
, 894, __PRETTY_FUNCTION__); } while (0);

      /* Make sure the header stays at the beginning */
      if (*a < t->n_columns && *b < t->n_columns)
              return 0;
      if (*a < t->n_columns)
              return -1;
      if (*b < t->n_columns)
              return 1;

      /* Order other lines by the sorting map */
      for (i = 0; i < t->n_sort_map; i++) {
              TableData *d, *dd;

              d = t->data[*a + t->sort_map[i]];
              dd = t->data[*b + t->sort_map[i]];

              r = cell_data_compare(d, *a, dd, *b);
              if (r != 0)
                      return t->reverse_map && t->reverse_map[t->sort_map[i]] ? -r : r;
      }

      /* Order identical lines by the order there were originally added in */
      if (*a < *b)
              return -1;
      if (*a > *b)
              return 1;

      return 0;
923}

925static const char *table_data_format(TableData *d) {
      assert(d)do { if ((__builtin_expect(!!(!(d)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("d"), "../src/basic/format-table.c", 926
, __PRETTY_FUNCTION__); } while (0);

      if (d->formatted)
              return d->formatted;

      switch (d->type) {
      case TABLE_EMPTY:
              return "";

      case TABLE_STRING:
              if (d->uppercase) {
                      char *p, *q;

                      d->formatted = new(char, strlen(d->string) + 1)((char*) malloc_multiply(sizeof(char), (strlen(d->string) +
 1)));
                      if (!d->formatted)
                              return NULL((void*)0);

                      for (p = d->string, q = d->formatted; *p; p++, q++)
                              *q = (char) toupper((unsigned char) *p);
                      *q = 0;

                      return d->formatted;
              }

              return d->string;

      case TABLE_BOOLEAN:
              return yes_no(d->boolean);

      case TABLE_TIMESTAMP: {
              _cleanup_free___attribute__((cleanup(freep))) char *p;

              p = new(char, FORMAT_TIMESTAMP_MAX)((char*) malloc_multiply(sizeof(char), ((3+1+10+1+8+1+6+1+6+1
))));
              if (!p)
                      return NULL((void*)0);

              if (!format_timestamp(p, FORMAT_TIMESTAMP_MAX(3+1+10+1+8+1+6+1+6+1), d->timestamp))
                      return "n/a";

              d->formatted = TAKE_PTR(p)({ typeof(p) _ptr_ = (p); (p) = ((void*)0); _ptr_; });
              break;
      }

      case TABLE_TIMESPAN: {
              _cleanup_free___attribute__((cleanup(freep))) char *p;

              p = new(char, FORMAT_TIMESPAN_MAX)((char*) malloc_multiply(sizeof(char), (64)));
              if (!p)
                      return NULL((void*)0);

              if (!format_timespan(p, FORMAT_TIMESPAN_MAX64, d->timespan, 0))
                      return "n/a";

              d->formatted = TAKE_PTR(p)({ typeof(p) _ptr_ = (p); (p) = ((void*)0); _ptr_; });
              break;
      }

      case TABLE_SIZE: {
              _cleanup_free___attribute__((cleanup(freep))) char *p;

              p = new(char, FORMAT_BYTES_MAX)((char*) malloc_multiply(sizeof(char), (8)));
              if (!p)
                      return NULL((void*)0);

              if (!format_bytes(p, FORMAT_BYTES_MAX8, d->size))
                      return "n/a";

              d->formatted = TAKE_PTR(p)({ typeof(p) _ptr_ = (p); (p) = ((void*)0); _ptr_; });
              break;
      }

      case TABLE_UINT32: {
              _cleanup_free___attribute__((cleanup(freep))) char *p;

              p = new(char, DECIMAL_STR_WIDTH(d->uint32) + 1)((char*) malloc_multiply(sizeof(char), (({ typeof(d->uint32
) _x_ = (d->uint32); unsigned ans = 1; while ((_x_ /= 10) !=
 0) ans++; ans; }) + 1)));
              if (!p)
                      return NULL((void*)0);

              sprintf(p, "%" PRIu32"u", d->uint32);
              d->formatted = TAKE_PTR(p)({ typeof(p) _ptr_ = (p); (p) = ((void*)0); _ptr_; });
              break;
      }

      case TABLE_UINT64: {
              _cleanup_free___attribute__((cleanup(freep))) char *p;

              p = new(char, DECIMAL_STR_WIDTH(d->uint64) + 1)((char*) malloc_multiply(sizeof(char), (({ typeof(d->uint64
) _x_ = (d->uint64); unsigned ans = 1; while ((_x_ /= 10) !=
 0) ans++; ans; }) + 1)));
              if (!p)
                      return NULL((void*)0);

              sprintf(p, "%" PRIu64"l" "u", d->uint64);
              d->formatted = TAKE_PTR(p)({ typeof(p) _ptr_ = (p); (p) = ((void*)0); _ptr_; });
              break;
      }

      case TABLE_PERCENT: {
              _cleanup_free___attribute__((cleanup(freep))) char *p;

              p = new(char, DECIMAL_STR_WIDTH(d->percent) + 2)((char*) malloc_multiply(sizeof(char), (({ typeof(d->percent
) _x_ = (d->percent); unsigned ans = 1; while ((_x_ /= 10)
 != 0) ans++; ans; }) + 2)));
              if (!p)
                      return NULL((void*)0);

              sprintf(p, "%i%%" , d->percent);
              d->formatted = TAKE_PTR(p)({ typeof(p) _ptr_ = (p); (p) = ((void*)0); _ptr_; });
              break;
      }

      default:
              assert_not_reached("Unexpected type?")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Unexpected type?"), "../src/basic/format-table.c", 1034, __PRETTY_FUNCTION__
); } while (0);
      }

      return d->formatted;
1038}

1040static int table_data_requested_width(TableData *d, size_t *ret) {
      const char *t;
      size_t l;

      t = table_data_format(d);
      if (!t)
              return -ENOMEM12;

      l = utf8_console_width(t);
      if (l == (size_t) -1)
              return -EINVAL22;

      if (d->maximum_width != (size_t) -1 && l > d->maximum_width)
              l = d->maximum_width;

      if (l < d->minimum_width)
              l = d->minimum_width;

      *ret = l;
      return 0;
1060}

1062static char *align_string_mem(const char *str, const char *url, size_t new_length, unsigned percent) {
      size_t w = 0, space, lspace, old_length, clickable_length;
      _cleanup_free___attribute__((cleanup(freep))) char *clickable = NULL((void*)0);
      const char *p;
      char *ret;
      size_t i;
      int r;

      /* As with ellipsize_mem(), 'old_length' is a byte size while 'new_length' is a width in character cells */

      assert(str)do { if ((__builtin_expect(!!(!(str)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("str"), "../src/basic/format-table.c", 1072
, __PRETTY_FUNCTION__); } while (0);
      assert(percent <= 100)do { if ((__builtin_expect(!!(!(percent <= 100)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("percent <= 100"), "../src/basic/format-table.c"
, 1073, __PRETTY_FUNCTION__); } while (0);

      old_length = strlen(str);

      if (url) {
              r = terminal_urlify(url, str, &clickable);
              if (r < 0)
                      return NULL((void*)0);

              clickable_length = strlen(clickable);
      } else
              clickable_length = old_length;

      /* Determine current width on screen */
      p = str;
      while (p < str + old_length) {
              char32_t c;

              if (utf8_encoded_to_unichar(p, &c) < 0) {
                      p++, w++; /* count invalid chars as 1 */
                      continue;
              }

              p = utf8_next_char(p)(char *)((p) + utf8_skip_data[*(const unsigned char *)(p)]);
              w += unichar_iswide(c) ? 2 : 1;
      }

      /* Already wider than the target, if so, don't do anything */
      if (w >= new_length)
              return clickable ? TAKE_PTR(clickable)({ typeof(clickable) _ptr_ = (clickable); (clickable) = ((void
*)0); _ptr_; }) : strdup(str);

      /* How much spaces shall we add? An how much on the left side? */
      space = new_length - w;
      lspace = space * percent / 100U;

      ret = new(char, space + clickable_length + 1)((char*) malloc_multiply(sizeof(char), (space + clickable_length
 + 1)));
      if (!ret)
              return NULL((void*)0);

      for (i = 0; i < lspace; i++)
              ret[i] = ' ';
      memcpy(ret + lspace, clickable ?: str, clickable_length);
      for (i = lspace + clickable_length; i < space + clickable_length; i++)
              ret[i] = ' ';

      ret[space + clickable_length] = 0;
      return ret;
1120}

1122int table_print(Table *t, FILE *f) {
      size_t n_rows, *minimum_width, *maximum_width, display_columns, *requested_width,
              i, j, table_minimum_width, table_maximum_width, table_requested_width, table_effective_width,
              *width;
      _cleanup_free___attribute__((cleanup(freep))) size_t *sorted = NULL((void*)0);
      uint64_t *column_weight, weight_sum;
      int r;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 1130
, __PRETTY_FUNCTION__); } while (0);
1
Assuming 't' is non-null→
2
←
Taking false branch→
3
←
Loop condition is false.  Exiting loop→

      if (!f)
4
←
Assuming 'f' is non-null→
5
←
Taking false branch→
              f = stdoutstdout;

      /* Ensure we have no incomplete rows */
      assert(t->n_cells % t->n_columns == 0)do { if ((__builtin_expect(!!(!(t->n_cells % t->n_columns
 == 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("t->n_cells % t->n_columns == 0"
), "../src/basic/format-table.c", 1136, __PRETTY_FUNCTION__);
 } while (0);
6
←
Assuming the condition is true→
7
←
Taking false branch→
8
←
Loop condition is false.  Exiting loop→

      n_rows = t->n_cells / t->n_columns;
      assert(n_rows > 0)do { if ((__builtin_expect(!!(!(n_rows > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("n_rows > 0"), "../src/basic/format-table.c"
, 1139, __PRETTY_FUNCTION__); } while (0); /* at least the header row must be complete */
9
←
Assuming 'n_rows' is > 0→
10
←
Taking false branch→
11
←
Loop condition is false.  Exiting loop→

      if (t->sort_map) {
12
←
Assuming field 'sort_map' is non-null→
13
←
Taking true branch→
              /* If sorting is requested, let's calculate an index table we use to lookup the actual index to display with. */

              sorted = new(size_t, n_rows)((size_t*) malloc_multiply(sizeof(size_t), (n_rows)));
14
←
Calling 'malloc_multiply'→
17
←
Returned allocated memory→
              if (!sorted)
18
←
Assuming 'sorted' is non-null→
19
←
Taking false branch→
                      return -ENOMEM12;

              for (i = 0; i19.1
'i' is < 'n_rows'
1
'i' is < 'n_rows'
 < n_rows; i++)
20
←
Loop condition is true.  Entering loop body→
21
←
Assuming 'i' is >= 'n_rows'→
22
←
Loop condition is false. Execution continues on line 1151→
                      sorted[i] = i * t->n_columns;

              qsort_r_safe(sorted, n_rows, sizeof(size_t), table_data_compare, t);
      }

      if (t->display_map)
23
←
Assuming field 'display_map' is null→
24
←
Taking false branch→
              display_columns = t->n_display_map;
      else
              display_columns = t->n_columns;

      assert(display_columns > 0)do { if ((__builtin_expect(!!(!(display_columns > 0)),0)))
 log_assert_failed_realm(LOG_REALM_SYSTEMD, ("display_columns > 0"
), "../src/basic/format-table.c", 1159, __PRETTY_FUNCTION__);
 } while (0);
25
←
Taking false branch→
26
←
Loop condition is false.  Exiting loop→

      minimum_width = newa(size_t, display_columns)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(size_t), display_columns))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("!size_multiply_overflow(sizeof(size_t), display_columns)"
), "../src/basic/format-table.c", 1161, __PRETTY_FUNCTION__);
 } while (0); (size_t*) __builtin_alloca (sizeof(size_t)*(display_columns
)); });
27
←
Taking false branch→
28
←
Loop condition is false.  Exiting loop→
      maximum_width = newa(size_t, display_columns)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(size_t), display_columns))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("!size_multiply_overflow(sizeof(size_t), display_columns)"
), "../src/basic/format-table.c", 1162, __PRETTY_FUNCTION__);
 } while (0); (size_t*) __builtin_alloca (sizeof(size_t)*(display_columns
)); });
29
←
Taking false branch→
30
←
Loop condition is false.  Exiting loop→
      requested_width = newa(size_t, display_columns)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(size_t), display_columns))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("!size_multiply_overflow(sizeof(size_t), display_columns)"
), "../src/basic/format-table.c", 1163, __PRETTY_FUNCTION__);
 } while (0); (size_t*) __builtin_alloca (sizeof(size_t)*(display_columns
)); });
31
←
Taking false branch→
32
←
Loop condition is false.  Exiting loop→
      width = newa(size_t, display_columns)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(size_t), display_columns))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("!size_multiply_overflow(sizeof(size_t), display_columns)"
), "../src/basic/format-table.c", 1164, __PRETTY_FUNCTION__);
 } while (0); (size_t*) __builtin_alloca (sizeof(size_t)*(display_columns
)); });
33
←
Taking false branch→
34
←
Loop condition is false.  Exiting loop→
      column_weight = newa0(uint64_t, display_columns)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(uint64_t), display_columns))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("!size_multiply_overflow(sizeof(uint64_t), display_columns)"
), "../src/basic/format-table.c", 1165, __PRETTY_FUNCTION__);
 } while (0); (uint64_t*) ({ char *_new_; size_t _len_ = sizeof
(uint64_t)*(display_columns); _new_ = __builtin_alloca (_len_
); (void *) memset(_new_, 0, _len_); }); });
35
←
Taking false branch→
36
←
Loop condition is false.  Exiting loop→

      for (j = 0; j36.1
'j' is < 'display_columns'
1
'j' is < 'display_columns'
 < display_columns; j++) {
37
←
Loop condition is true.  Entering loop body→
38
←
Assuming 'j' is >= 'display_columns'→
39
←
Loop condition is false. Execution continues on line 1174→
              minimum_width[j] = 1;
              maximum_width[j] = (size_t) -1;
              requested_width[j] = (size_t) -1;
      }

      /* First pass: determine column sizes */
      for (i = t->header ? 0 : 1; i < n_rows; i++) {
40
←
Assuming field 'header' is true→
41
←
'?' condition is true→
42
←
Loop condition is true.  Entering loop body→
              TableData **row;

              /* Note that we don't care about ordering at this time, as we just want to determine column sizes,
               * hence we don't care for sorted[] during the first pass. */
              row = t->data + i * t->n_columns;

              for (j = 0; j < display_columns; j++) {
43
←
Loop condition is true.  Entering loop body→
                      TableData *d;
                      size_t req;

                      assert_se(d = row[t->display_map ? t->display_map[j] : j])do { if ((__builtin_expect(!!(!(d = row[t->display_map ? t
->display_map[j] : j])),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("d = row[t->display_map ? t->display_map[j] : j]"), "../src/basic/format-table.c"
, 1185, __PRETTY_FUNCTION__); } while (0);
44
←
'?' condition is false→
45
←
Assuming 'd' is non-null→
46
←
Taking false branch→
47
←
Loop condition is false.  Exiting loop→

                      r = table_data_requested_width(d, &req);
                      if (r47.1
'r' is < 0
1
'r' is < 0
 < 0)
48
←
Taking true branch→
                              return r;
49
←
Potential leak of memory pointed to by 'sorted'

                      /* Determine the biggest width that any cell in this column would like to have */
                      if (requested_width[j] == (size_t) -1 ||
                          requested_width[j] < req)
                              requested_width[j] = req;

                      /* Determine the minimum width any cell in this column needs */
                      if (minimum_width[j] < d->minimum_width)
                              minimum_width[j] = d->minimum_width;

                      /* Determine the maximum width any cell in this column needs */
                      if (d->maximum_width != (size_t) -1 &&
                          (maximum_width[j] == (size_t) -1 ||
                           maximum_width[j] > d->maximum_width))
                              maximum_width[j] = d->maximum_width;

                      /* Determine the full columns weight */
                      column_weight[j] += d->weight;
              }
      }

      /* One space between each column */
      table_requested_width = table_minimum_width = table_maximum_width = display_columns - 1;

      /* Calculate the total weight for all columns, plus the minimum, maximum and requested width for the table. */
      weight_sum = 0;
      for (j = 0; j < display_columns; j++) {
              weight_sum += column_weight[j];

              table_minimum_width += minimum_width[j];

              if (maximum_width[j] == (size_t) -1)
                      table_maximum_width = (size_t) -1;
              else
                      table_maximum_width += maximum_width[j];

              table_requested_width += requested_width[j];
      }

      /* Calculate effective table width */
      if (t->width == (size_t) -1)
              table_effective_width = pager_have() ? table_requested_width : MIN(table_requested_width, columns())__extension__ ({ const typeof((table_requested_width)) __unique_prefix_A118
 = ((table_requested_width)); const typeof((columns())) __unique_prefix_B119
 = ((columns())); __unique_prefix_A118 < __unique_prefix_B119
 ? __unique_prefix_A118 : __unique_prefix_B119; });
      else
              table_effective_width = t->width;

      if (table_maximum_width != (size_t) -1 && table_effective_width > table_maximum_width)
              table_effective_width = table_maximum_width;

      if (table_effective_width < table_minimum_width)
              table_effective_width = table_minimum_width;

      if (table_effective_width >= table_requested_width) {
              size_t extra;

              /* We have extra room, let's distribute it among columns according to their weights. We first provide
               * each column with what it asked for and the distribute the rest.  */

              extra = table_effective_width - table_requested_width;

              for (j = 0; j < display_columns; j++) {
                      size_t delta;

                      if (weight_sum == 0)
                              width[j] = requested_width[j] + extra / (display_columns - j); /* Avoid division by zero */
                      else
                              width[j] = requested_width[j] + (extra * column_weight[j]) / weight_sum;

                      if (maximum_width[j] != (size_t) -1 && width[j] > maximum_width[j])
                              width[j] = maximum_width[j];

                      if (width[j] < minimum_width[j])
                              width[j] = minimum_width[j];

                      assert(width[j] >= requested_width[j])do { if ((__builtin_expect(!!(!(width[j] >= requested_width
[j])),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("width[j] >= requested_width[j]"
), "../src/basic/format-table.c", 1263, __PRETTY_FUNCTION__);
 } while (0);
                      delta = width[j] - requested_width[j];

                      /* Subtract what we just added from the rest */
                      if (extra > delta)
                              extra -= delta;
                      else
                              extra = 0;

                      assert(weight_sum >= column_weight[j])do { if ((__builtin_expect(!!(!(weight_sum >= column_weight
[j])),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("weight_sum >= column_weight[j]"
), "../src/basic/format-table.c", 1272, __PRETTY_FUNCTION__);
 } while (0);
                      weight_sum -= column_weight[j];
              }

      } else {
              /* We need to compress the table, columns can't get what they asked for. We first provide each column
               * with the minimum they need, and then distribute anything left. */
              bool_Bool finalize = false0;
              size_t extra;

              extra = table_effective_width - table_minimum_width;

              for (j = 0; j < display_columns; j++)
                      width[j] = (size_t) -1;

              for (;;) {
                      bool_Bool restart = false0;

                      for (j = 0; j < display_columns; j++) {
                              size_t delta, w;

                              /* Did this column already get something assigned? If so, let's skip to the next */
                              if (width[j] != (size_t) -1)
                                      continue;

                              if (weight_sum == 0)
                                      w = minimum_width[j] + extra / (display_columns - j); /* avoid division by zero */
                              else
                                      w = minimum_width[j] + (extra * column_weight[j]) / weight_sum;

                              if (w >= requested_width[j]) {
                                      /* Never give more than requested. If we hit a column like this, there's more
                                       * space to allocate to other columns which means we need to restart the
                                       * iteration. However, if we hit a column like this, let's assign it the space
                                       * it wanted for good early.*/

                                      w = requested_width[j];
                                      restart = true1;

                              } else if (!finalize)
                                      continue;

                              width[j] = w;

                              assert(w >= minimum_width[j])do { if ((__builtin_expect(!!(!(w >= minimum_width[j])),0)
)) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("w >= minimum_width[j]"
), "../src/basic/format-table.c", 1316, __PRETTY_FUNCTION__);
 } while (0);
                              delta = w - minimum_width[j];

                              assert(delta <= extra)do { if ((__builtin_expect(!!(!(delta <= extra)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("delta <= extra"), "../src/basic/format-table.c"
, 1319, __PRETTY_FUNCTION__); } while (0);
                              extra -= delta;

                              assert(weight_sum >= column_weight[j])do { if ((__builtin_expect(!!(!(weight_sum >= column_weight
[j])),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("weight_sum >= column_weight[j]"
), "../src/basic/format-table.c", 1322, __PRETTY_FUNCTION__);
 } while (0);
                              weight_sum -= column_weight[j];

                              if (restart)
                                      break;
                      }

                      if (finalize) {
                              assert(!restart)do { if ((__builtin_expect(!!(!(!restart)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!restart"), "../src/basic/format-table.c"
, 1330, __PRETTY_FUNCTION__); } while (0);
                              break;
                      }

                      if (!restart)
                              finalize = true1;
              }
      }

      /* Second pass: show output */
      for (i = t->header ? 0 : 1; i < n_rows; i++) {
              TableData **row;

              if (sorted)
                      row = t->data + sorted[i];
              else
                      row = t->data + i * t->n_columns;

              for (j = 0; j < display_columns; j++) {
                      _cleanup_free___attribute__((cleanup(freep))) char *buffer = NULL((void*)0);
                      const char *field;
                      TableData *d;
                      size_t l;

                      assert_se(d = row[t->display_map ? t->display_map[j] : j])do { if ((__builtin_expect(!!(!(d = row[t->display_map ? t
->display_map[j] : j])),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("d = row[t->display_map ? t->display_map[j] : j]"), "../src/basic/format-table.c"
, 1354, __PRETTY_FUNCTION__); } while (0);

                      field = table_data_format(d);
                      if (!field)
                              return -ENOMEM12;

                      l = utf8_console_width(field);
                      if (l > width[j]) {
                              /* Field is wider than allocated space. Let's ellipsize */

                              buffer = ellipsize(field, width[j], d->ellipsize_percent);
                              if (!buffer)
                                      return -ENOMEM12;

                              field = buffer;

                      } else if (l < width[j]) {
                              /* Field is shorter than allocated space. Let's align with spaces */

                              buffer = align_string_mem(field, d->url, width[j], d->align_percent);
                              if (!buffer)
                                      return -ENOMEM12;

                              field = buffer;
                      }

                      if (l >= width[j] && d->url) {
                              _cleanup_free___attribute__((cleanup(freep))) char *clickable = NULL((void*)0);

                              r = terminal_urlify(d->url, field, &clickable);
                              if (r < 0)
                                      return r;

                              free_and_replace(buffer, clickable)({ free(buffer); (buffer) = (clickable); (clickable) = ((void
*)0); 0; });
                              field = buffer;
                      }

                      if (row == t->data) /* underline header line fully, including the column separator */
                              fputs(ansi_underline(), f);

                      if (j > 0)
                              fputc(' ', f); /* column separator */

                      if (d->color && colors_enabled()) {
                              if (row == t->data) /* first undo header underliner */
                                      fputs(ANSI_NORMAL"\x1B[0m", f);

                              fputs(d->color, f);
                      }

                      fputs(field, f);

                      if (colors_enabled() && (d->color || row == t->data))
                              fputs(ANSI_NORMAL"\x1B[0m", f);
              }

              fputc('\n', f);
      }

      return fflush_and_check(f);
1414}

1416int table_format(Table *t, char **ret) {
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      char *buf = NULL((void*)0);
      size_t sz = 0;
      int r;

      f = open_memstream(&buf, &sz);
      if (!f)
              return -ENOMEM12;

      (void) __fsetlocking(f, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);

      r = table_print(t, f);
      if (r < 0)
              return r;

      f = safe_fclose(f);

      *ret = buf;

      return 0;
1437}

1439size_t table_get_rows(Table *t) {
      if (!t)
              return 0;

      assert(t->n_columns > 0)do { if ((__builtin_expect(!!(!(t->n_columns > 0)),0)))
 log_assert_failed_realm(LOG_REALM_SYSTEMD, ("t->n_columns > 0"
), "../src/basic/format-table.c", 1443, __PRETTY_FUNCTION__);
 } while (0);
      return t->n_cells / t->n_columns;
1445}

1447size_t table_get_columns(Table *t) {
      if (!t)
              return 0;

      assert(t->n_columns > 0)do { if ((__builtin_expect(!!(!(t->n_columns > 0)),0)))
 log_assert_failed_realm(LOG_REALM_SYSTEMD, ("t->n_columns > 0"
), "../src/basic/format-table.c", 1451, __PRETTY_FUNCTION__);
 } while (0);
      return t->n_columns;
1453}

1455int table_set_reverse(Table *t, size_t column, bool_Bool b) {
      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 1456
, __PRETTY_FUNCTION__); } while (0);
      assert(column < t->n_columns)do { if ((__builtin_expect(!!(!(column < t->n_columns))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("column < t->n_columns"
), "../src/basic/format-table.c", 1457, __PRETTY_FUNCTION__);
 } while (0);

      if (!t->reverse_map) {
              if (!b)
                      return 0;

              t->reverse_map = new0(bool, t->n_columns)((_Bool*) calloc((t->n_columns), sizeof(_Bool)));
              if (!t->reverse_map)
                      return -ENOMEM12;
      }

      t->reverse_map[column] = b;
      return 0;
1470}

1472TableCell *table_get_cell(Table *t, size_t row, size_t column) {
      size_t i;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 1475
, __PRETTY_FUNCTION__); } while (0);

      if (column >= t->n_columns)
              return NULL((void*)0);

      i = row * t->n_columns + column;
      if (i >= t->n_cells)
              return NULL((void*)0);

      return TABLE_INDEX_TO_CELL(i);
1485}

1487const void *table_get(Table *t, TableCell *cell) {
      TableData *d;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/basic/format-table.c", 1490
, __PRETTY_FUNCTION__); } while (0);

      d = table_get_data(t, cell);
      if (!d)
              return NULL((void*)0);

      return d->data;
1497}

1499const void* table_get_at(Table *t, size_t row, size_t column) {
      TableCell *cell;

      cell = table_get_cell(t, row, column);
      if (!cell)
              return NULL((void*)0);

      return table_get(t, cell);
1507}

←

../src/basic/alloc-util.h

1/* SPDX-License-Identifier: LGPL-2.1+ */
2#pragma once
3 
4#include <alloca.h>
5#include <stddef.h>
6#include <stdlib.h>
7#include <string.h>
8 
9#include "macro.h"
10 
11#define new(t, n)((t*) malloc_multiply(sizeof(t), (n))) ((t*) malloc_multiply(sizeof(t), (n)))
12 
13#define new0(t, n)((t*) calloc((n), sizeof(t))) ((t*) calloc((n), sizeof(t)))
14 
15#define newa(t, n)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(t), n))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("!size_multiply_overflow(sizeof(t), n)"
), "../src/basic/alloc-util.h", 15, __PRETTY_FUNCTION__); } while
 (0); (t*) __builtin_alloca (sizeof(t)*(n)); })                                              \
16        ({                                                      \
17                assert(!size_multiply_overflow(sizeof(t), n))do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(t), n))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("!size_multiply_overflow(sizeof(t), n)"
), "../src/basic/alloc-util.h", 17, __PRETTY_FUNCTION__); } while
 (0);  \
18                (t*) alloca(sizeof(t)*(n))__builtin_alloca (sizeof(t)*(n));                     \
19        })
20 
21#define newa0(t, n)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(t), n))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("!size_multiply_overflow(sizeof(t), n)"
), "../src/basic/alloc-util.h", 21, __PRETTY_FUNCTION__); } while
 (0); (t*) ({ char *_new_; size_t _len_ = sizeof(t)*(n); _new_
 = __builtin_alloca (_len_); (void *) memset(_new_, 0, _len_)
; }); })                                             \
22        ({                                                      \
23                assert(!size_multiply_overflow(sizeof(t), n))do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(t), n))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("!size_multiply_overflow(sizeof(t), n)"
), "../src/basic/alloc-util.h", 23, __PRETTY_FUNCTION__); } while
 (0);  \
24                (t*) alloca0(sizeof(t)*(n))({ char *_new_; size_t _len_ = sizeof(t)*(n); _new_ = __builtin_alloca
 (_len_); (void *) memset(_new_, 0, _len_); });                    \
25        })
26 
27#define newdup(t, p, n)((t*) memdup_multiply(p, sizeof(t), (n))) ((t*) memdup_multiply(p, sizeof(t), (n)))
28 
29#define newdup_suffix0(t, p, n)((t*) memdup_suffix0_multiply(p, sizeof(t), (n))) ((t*) memdup_suffix0_multiply(p, sizeof(t), (n)))
30 
31#define malloc0(n)(calloc(1, (n))) (calloc(1, (n)))
32 
33static inline void *mfree(void *memory) {
34        free(memory);
35        return NULL((void*)0);
36}
37 
38#define free_and_replace(a, b)({ free(a); (a) = (b); (b) = ((void*)0); 0; })                  \
39        ({                                      \
40                free(a);                        \
41                (a) = (b);                      \
42                (b) = NULL((void*)0);                     \
43                0;                              \
44        })
45 
46void* memdup(const void *p, size_t l) _alloc_(2);
47void* memdup_suffix0(const void *p, size_t l) _alloc_(2);
48 
49static inline void freep(void *p) {
50        free(*(void**) p);
51}
52 
53#define _cleanup_free___attribute__((cleanup(freep))) _cleanup_(freep)__attribute__((cleanup(freep)))
54 
55static inline bool_Bool size_multiply_overflow(size_t size, size_t need) {
56        return _unlikely_(need != 0 && size > (SIZE_MAX / need))(__builtin_expect(!!(need != 0 && size > ((18446744073709551615UL
) / need)),0));
57}
58 
59_malloc___attribute__ ((malloc))  _alloc_(1, 2) static inline void *malloc_multiply(size_t size, size_t need) {
60        if (size_multiply_overflow(size, need))
15
←
Taking false branch→
61                return NULL((void*)0);
62 
63        return malloc(size * need);
16
←
Memory is allocated→
64}
65 
66#if !HAVE_REALLOCARRAY1
67_alloc_(2, 3) static inline void *reallocarray(void *p, size_t need, size_t size) {
68        if (size_multiply_overflow(size, need))
69                return NULL((void*)0);
70 
71        return realloc(p, size * need);
72}
73#endif
74 
75_alloc_(2, 3) static inline void *memdup_multiply(const void *p, size_t size, size_t need) {
76        if (size_multiply_overflow(size, need))
77                return NULL((void*)0);
78 
79        return memdup(p, size * need);
80}
81 
82_alloc_(2, 3) static inline void *memdup_suffix0_multiply(const void *p, size_t size, size_t need) {
83        if (size_multiply_overflow(size, need))
84                return NULL((void*)0);
85 
86        return memdup_suffix0(p, size * need);
87}
88 
89void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size);
90void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size);
91 
92#define GREEDY_REALLOC(array, allocated, need)greedy_realloc((void**) &(array), &(allocated), (need
), sizeof((array)[0]))                          \
93        greedy_realloc((void**) &(array), &(allocated), (need), sizeof((array)[0]))
94 
95#define GREEDY_REALLOC0(array, allocated, need)greedy_realloc0((void**) &(array), &(allocated), (need
), sizeof((array)[0]))                         \
96        greedy_realloc0((void**) &(array), &(allocated), (need), sizeof((array)[0]))
97 
98#define alloca0(n)({ char *_new_; size_t _len_ = n; _new_ = __builtin_alloca (_len_
); (void *) memset(_new_, 0, _len_); })                                      \
99        ({                                              \
100                char *_new_;                            \
101                size_t _len_ = n;                       \
102                _new_ = alloca(_len_)__builtin_alloca (_len_);                  \
103                (void *) memset(_new_, 0, _len_);       \
104        })
105 
106/* It's not clear what alignment glibc/gcc alloca() guarantee, hence provide a guaranteed safe version */
107#define alloca_align(size, align)({ void *_ptr_; size_t _mask_ = (align) - 1; _ptr_ = __builtin_alloca
 ((size) + _mask_); (void*)(((uintptr_t)_ptr_ + _mask_) &
 ~_mask_); })                                       \
108        ({                                                              \
109                void *_ptr_;                                            \
110                size_t _mask_ = (align) - 1;                            \
111                _ptr_ = alloca((size) + _mask_)__builtin_alloca ((size) + _mask_);                        \
112                (void*)(((uintptr_t)_ptr_ + _mask_) & ~_mask_);         \
113        })
114 
115#define alloca0_align(size, align)({ void *_new_; size_t _size_ = (size); _new_ = ({ void *_ptr_
; size_t _mask_ = ((align)) - 1; _ptr_ = __builtin_alloca ((_size_
) + _mask_); (void*)(((uintptr_t)_ptr_ + _mask_) & ~_mask_
); }); (void*)memset(_new_, 0, _size_); })                                      \
116        ({                                                              \
117                void *_new_;                                            \
118                size_t _size_ = (size);                                 \
119                _new_ = alloca_align(_size_, (align))({ void *_ptr_; size_t _mask_ = ((align)) - 1; _ptr_ = __builtin_alloca
 ((_size_) + _mask_); (void*)(((uintptr_t)_ptr_ + _mask_) &
 ~_mask_); });                  \
120                (void*)memset(_new_, 0, _size_);                        \
121        })
122 
123/* Takes inspiration from Rusts's Option::take() method: reads and returns a pointer, but at the same time resets it to
124 * NULL. See: https://doc.rust-lang.org/std/option/enum.Option.html#method.take */
125#define TAKE_PTR(ptr)({ typeof(ptr) _ptr_ = (ptr); (ptr) = ((void*)0); _ptr_; })                           \
126        ({                                      \
127                typeof(ptr) _ptr_ = (ptr);      \
128                (ptr) = NULL((void*)0);                   \
129                _ptr_;                          \
130        })