Clean-up: run format-cpp on the tree

[lttng-tools.git] / src / common / argpar / argpar.c

diff --git a/src/common/argpar/argpar.c b/src/common/argpar/argpar.c
index 82b561ceaae707002f36754c55e828d35b882206..f8280ce1423a5c609fd34e5451bab875c4e186eb 100644 (file)
--- a/src/common/argpar/argpar.c
+++ b/src/common/argpar/argpar.c
@@ -5,19 +5,17 @@
  * Copyright (c) 2020-2021 Simon Marchi <simon.marchi@efficios.com>
  */
 
+#include "argpar.h"
+
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "argpar.h"
-
-#define ARGPAR_REALLOC(_ptr, _type, _nmemb)                            \
-       ((_type *) realloc(_ptr, (_nmemb) * sizeof(_type)))
+#define ARGPAR_REALLOC(_ptr, _type, _nmemb) ((_type *) realloc(_ptr, (_nmemb) * sizeof(_type)))
 
-#define ARGPAR_CALLOC(_type, _nmemb)                                   \
-       ((_type *) calloc((_nmemb), sizeof(_type)))
+#define ARGPAR_CALLOC(_type, _nmemb) ((_type *) calloc((_nmemb), sizeof(_type)))
 
 #define ARGPAR_ZALLOC(_type) ARGPAR_CALLOC(_type, 1)
 
@@ -26,10 +24,10 @@
  * Force usage of the assertion condition to prevent unused variable warnings
  * when `assert()` are disabled by the `NDEBUG` definition.
  */
-# define ARGPAR_ASSERT(_cond) ((void) sizeof((void) (_cond), 0))
+#define ARGPAR_ASSERT(_cond) ((void) sizeof((void) (_cond), 0))
 #else
-# include <assert.h>
-# define ARGPAR_ASSERT(_cond) assert(_cond)
+#include <assert.h>
+#define ARGPAR_ASSERT(_cond) assert(_cond)
 #endif
 
 /*
@@ -45,7 +43,7 @@ struct argpar_iter {
         */
        struct {
                unsigned int argc;
-               const char * const *argv;
+               const char *const *argv;
                const struct argpar_opt_descr *descrs;
        } user;
 
@@ -128,15 +126,14 @@ struct argpar_error {
 };
 
 ARGPAR_HIDDEN
-enum argpar_item_type argpar_item_type(const struct argpar_item * const item)
+enum argpar_item_type argpar_item_type(const struct argpar_item *const item)
 {
        ARGPAR_ASSERT(item);
        return item->type;
 }
 
 ARGPAR_HIDDEN
-const struct argpar_opt_descr *argpar_item_opt_descr(
-               const struct argpar_item * const item)
+const struct argpar_opt_descr *argpar_item_opt_descr(const struct argpar_item *const item)
 {
        ARGPAR_ASSERT(item);
        ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_OPT);
@@ -144,7 +141,7 @@ const struct argpar_opt_descr *argpar_item_opt_descr(
 }
 
 ARGPAR_HIDDEN
-const char *argpar_item_opt_arg(const struct argpar_item * const item)
+const char *argpar_item_opt_arg(const struct argpar_item *const item)
 {
        ARGPAR_ASSERT(item);
        ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_OPT);
@@ -152,7 +149,7 @@ const char *argpar_item_opt_arg(const struct argpar_item * const item)
 }
 
 ARGPAR_HIDDEN
-const char *argpar_item_non_opt_arg(const struct argpar_item * const item)
+const char *argpar_item_non_opt_arg(const struct argpar_item *const item)
 {
        ARGPAR_ASSERT(item);
        ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT);
@@ -160,8 +157,7 @@ const char *argpar_item_non_opt_arg(const struct argpar_item * const item)
 }
 
 ARGPAR_HIDDEN
-unsigned int argpar_item_non_opt_orig_index(
-               const struct argpar_item * const item)
+unsigned int argpar_item_non_opt_orig_index(const struct argpar_item *const item)
 {
        ARGPAR_ASSERT(item);
        ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT);
@@ -169,8 +165,7 @@ unsigned int argpar_item_non_opt_orig_index(
 }
 
 ARGPAR_HIDDEN
-unsigned int argpar_item_non_opt_non_opt_index(
-               const struct argpar_item * const item)
+unsigned int argpar_item_non_opt_non_opt_index(const struct argpar_item *const item)
 {
        ARGPAR_ASSERT(item);
        ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT);
@@ -178,15 +173,14 @@ unsigned int argpar_item_non_opt_non_opt_index(
 }
 
 ARGPAR_HIDDEN
-void argpar_item_destroy(const struct argpar_item * const item)
+void argpar_item_destroy(const struct argpar_item *const item)
 {
        if (!item) {
                goto end;
        }
 
        if (item->type == ARGPAR_ITEM_TYPE_OPT) {
-               struct argpar_item_opt * const opt_item =
-                       (struct argpar_item_opt *) item;
+               struct argpar_item_opt *const opt_item = (struct argpar_item_opt *) item;
 
                free(opt_item->arg);
        }
@@ -203,13 +197,10 @@ end:
  *
  * Returns `NULL` on memory error.
  */
-static
-struct argpar_item_opt *create_opt_item(
-               const struct argpar_opt_descr * const descr,
-               const char * const arg)
+static struct argpar_item_opt *create_opt_item(const struct argpar_opt_descr *const descr,
+                                              const char *const arg)
 {
-       struct argpar_item_opt *opt_item =
-               ARGPAR_ZALLOC(struct argpar_item_opt);
+       struct argpar_item_opt *opt_item = ARGPAR_ZALLOC(struct argpar_item_opt);
 
        if (!opt_item) {
                goto end;
@@ -242,13 +233,11 @@ end:
  *
  * Returns `NULL` on memory error.
  */
-static
-struct argpar_item_non_opt *create_non_opt_item(const char * const arg,
-               const unsigned int orig_index,
-               const unsigned int non_opt_index)
+static struct argpar_item_non_opt *create_non_opt_item(const char *const arg,
+                                                      const unsigned int orig_index,
+                                                      const unsigned int non_opt_index)
 {
-       struct argpar_item_non_opt * const non_opt_item =
-               ARGPAR_ZALLOC(struct argpar_item_non_opt);
+       struct argpar_item_non_opt *const non_opt_item = ARGPAR_ZALLOC(struct argpar_item_non_opt);
 
        if (!non_opt_item) {
                goto end;
@@ -274,12 +263,11 @@ end:
  * Returns 0 on success (including if `error` is `NULL`) or -1 on memory
  * error.
  */
-static
-int set_error(struct argpar_error ** const error,
-               enum argpar_error_type type,
-               const char * const unknown_opt_name,
-               const struct argpar_opt_descr * const opt_descr,
-               const bool is_short)
+static int set_error(struct argpar_error **const error,
+                    enum argpar_error_type type,
+                    const char *const unknown_opt_name,
+                    const struct argpar_opt_descr *const opt_descr,
+                    const bool is_short)
 {
        int ret = 0;
 
@@ -295,8 +283,8 @@ int set_error(struct argpar_error ** const error,
        (*error)->type = type;
 
        if (unknown_opt_name) {
-               (*error)->unknown_opt_name = ARGPAR_CALLOC(char,
-                       strlen(unknown_opt_name) + 1 + (is_short ? 1 : 2));
+               (*error)->unknown_opt_name =
+                       ARGPAR_CALLOC(char, strlen(unknown_opt_name) + 1 + (is_short ? 1 : 2));
                if (!(*error)->unknown_opt_name) {
                        goto error;
                }
@@ -323,23 +311,21 @@ end:
 }
 
 ARGPAR_HIDDEN
-enum argpar_error_type argpar_error_type(
-               const struct argpar_error * const error)
+enum argpar_error_type argpar_error_type(const struct argpar_error *const error)
 {
        ARGPAR_ASSERT(error);
        return error->type;
 }
 
 ARGPAR_HIDDEN
-unsigned int argpar_error_orig_index(const struct argpar_error * const error)
+unsigned int argpar_error_orig_index(const struct argpar_error *const error)
 {
        ARGPAR_ASSERT(error);
        return error->orig_index;
 }
 
 ARGPAR_HIDDEN
-const char *argpar_error_unknown_opt_name(
-               const struct argpar_error * const error)
+const char *argpar_error_unknown_opt_name(const struct argpar_error *const error)
 {
        ARGPAR_ASSERT(error);
        ARGPAR_ASSERT(error->type == ARGPAR_ERROR_TYPE_UNKNOWN_OPT);
@@ -348,12 +334,12 @@ const char *argpar_error_unknown_opt_name(
 }
 
 ARGPAR_HIDDEN
-const struct argpar_opt_descr *argpar_error_opt_descr(
-               const struct argpar_error * const error, bool * const is_short)
+const struct argpar_opt_descr *argpar_error_opt_descr(const struct argpar_error *const error,
+                                                     bool *const is_short)
 {
        ARGPAR_ASSERT(error);
        ARGPAR_ASSERT(error->type == ARGPAR_ERROR_TYPE_MISSING_OPT_ARG ||
-               error->type == ARGPAR_ERROR_TYPE_UNEXPECTED_OPT_ARG);
+                     error->type == ARGPAR_ERROR_TYPE_UNEXPECTED_OPT_ARG);
        ARGPAR_ASSERT(error->opt_descr);
 
        if (is_short) {
@@ -364,7 +350,7 @@ const struct argpar_opt_descr *argpar_error_opt_descr(
 }
 
 ARGPAR_HIDDEN
-void argpar_error_destroy(const struct argpar_error * const error)
+void argpar_error_destroy(const struct argpar_error *const error)
 {
        if (error) {
                free(error->unknown_opt_name);
@@ -383,21 +369,18 @@ void argpar_error_destroy(const struct argpar_error * const error)
  *
  * Returns `NULL` if no descriptor is found.
  */
-static
-const struct argpar_opt_descr *find_descr(
-               const struct argpar_opt_descr * const descrs,
-               const char short_name, const char * const long_name)
+static const struct argpar_opt_descr *find_descr(const struct argpar_opt_descr *const descrs,
+                                                const char short_name,
+                                                const char *const long_name)
 {
        const struct argpar_opt_descr *descr;
 
        for (descr = descrs; descr->short_name || descr->long_name; descr++) {
-               if (short_name && descr->short_name &&
-                               short_name == descr->short_name) {
+               if (short_name && descr->short_name && short_name == descr->short_name) {
                        goto end;
                }
 
-               if (long_name && descr->long_name &&
-                               strcmp(long_name, descr->long_name) == 0) {
+               if (long_name && descr->long_name && strcmp(long_name, descr->long_name) == 0) {
                        goto end;
                }
        }
@@ -422,14 +405,13 @@ enum parse_orig_arg_opt_ret {
  * On error (except for `PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY`), sets
  * `*error`.
  */
-static
-enum parse_orig_arg_opt_ret parse_short_opt_group(
-               const char * const short_opt_group,
-               const char * const next_orig_arg,
-               const struct argpar_opt_descr * const descrs,
-               struct argpar_iter * const iter,
-               struct argpar_error ** const error,
-               struct argpar_item ** const item)
+static enum parse_orig_arg_opt_ret
+parse_short_opt_group(const char *const short_opt_group,
+                     const char *const next_orig_arg,
+                     const struct argpar_opt_descr *const descrs,
+                     struct argpar_iter *const iter,
+                     struct argpar_error **const error,
+                     struct argpar_item **const item)
 {
        enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
        bool used_next_orig_arg = false;
@@ -446,13 +428,11 @@ enum parse_orig_arg_opt_ret parse_short_opt_group(
        /* Find corresponding option descriptor */
        descr = find_descr(descrs, *iter->short_opt_group_ch, NULL);
        if (!descr) {
-               const char unknown_opt_name[] =
-                       {*iter->short_opt_group_ch, '\0'};
+               const char unknown_opt_name[] = { *iter->short_opt_group_ch, '\0' };
 
                ret = PARSE_ORIG_ARG_OPT_RET_ERROR;
 
-               if (set_error(error, ARGPAR_ERROR_TYPE_UNKNOWN_OPT,
-                               unknown_opt_name, NULL, true)) {
+               if (set_error(error, ARGPAR_ERROR_TYPE_UNKNOWN_OPT, unknown_opt_name, NULL, true)) {
                        ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
                }
 
@@ -473,12 +453,10 @@ enum parse_orig_arg_opt_ret parse_short_opt_group(
                 * We accept `-o ''` (empty option argument), but not
                 * `-o` alone if an option argument is expected.
                 */
-               if (!opt_arg || (iter->short_opt_group_ch[1] &&
-                               strlen(opt_arg) == 0)) {
+               if (!opt_arg || (iter->short_opt_group_ch[1] && strlen(opt_arg) == 0)) {
                        ret = PARSE_ORIG_ARG_OPT_RET_ERROR;
 
-                       if (set_error(error, ARGPAR_ERROR_TYPE_MISSING_OPT_ARG,
-                                       NULL, descr, true)) {
+                       if (set_error(error, ARGPAR_ERROR_TYPE_MISSING_OPT_ARG, NULL, descr, true)) {
                                ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
                        }
 
@@ -524,13 +502,12 @@ end:
  * On error (except for `PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY`), sets
  * `*error`.
  */
-static
-enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
-               const char * const next_orig_arg,
-               const struct argpar_opt_descr * const descrs,
-               struct argpar_iter * const iter,
-               struct argpar_error ** const error,
-               struct argpar_item ** const item)
+static enum parse_orig_arg_opt_ret parse_long_opt(const char *const long_opt_arg,
+                                                 const char *const next_orig_arg,
+                                                 const struct argpar_opt_descr *const descrs,
+                                                 struct argpar_iter *const iter,
+                                                 struct argpar_error **const error,
+                                                 struct argpar_item **const item)
 {
        enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
        const struct argpar_opt_descr *descr;
@@ -556,8 +533,8 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
                /* Isolate the option name */
                while (long_opt_name_size > iter->tmp_buf.size - 1) {
                        iter->tmp_buf.size *= 2;
-                       iter->tmp_buf.data = ARGPAR_REALLOC(iter->tmp_buf.data,
-                               char, iter->tmp_buf.size);
+                       iter->tmp_buf.data =
+                               ARGPAR_REALLOC(iter->tmp_buf.data, char, iter->tmp_buf.size);
                        if (!iter->tmp_buf.data) {
                                ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
                                goto error;
@@ -574,8 +551,7 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
        if (!descr) {
                ret = PARSE_ORIG_ARG_OPT_RET_ERROR;
 
-               if (set_error(error, ARGPAR_ERROR_TYPE_UNKNOWN_OPT,
-                               long_opt_name, NULL, false)) {
+               if (set_error(error, ARGPAR_ERROR_TYPE_UNKNOWN_OPT, long_opt_name, NULL, false)) {
                        ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
                }
 
@@ -592,8 +568,11 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
                        if (!next_orig_arg) {
                                ret = PARSE_ORIG_ARG_OPT_RET_ERROR;
 
-                               if (set_error(error, ARGPAR_ERROR_TYPE_MISSING_OPT_ARG,
-                                               NULL, descr, false)) {
+                               if (set_error(error,
+                                             ARGPAR_ERROR_TYPE_MISSING_OPT_ARG,
+                                             NULL,
+                                             descr,
+                                             false)) {
                                        ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
                                }
 
@@ -610,8 +589,7 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
                 */
                ret = PARSE_ORIG_ARG_OPT_RET_ERROR;
 
-               if (set_error(error, ARGPAR_ERROR_TYPE_UNEXPECTED_OPT_ARG,
-                               NULL, descr, false)) {
+               if (set_error(error, ARGPAR_ERROR_TYPE_UNEXPECTED_OPT_ARG, NULL, descr, false)) {
                        ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
                }
 
@@ -648,13 +626,12 @@ end:
  * On error (except for `PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY`), sets
  * `*error`.
  */
-static
-enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg,
-               const char * const next_orig_arg,
-               const struct argpar_opt_descr * const descrs,
-               struct argpar_iter * const iter,
-               struct argpar_error ** const error,
-               struct argpar_item ** const item)
+static enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char *const orig_arg,
+                                                     const char *const next_orig_arg,
+                                                     const struct argpar_opt_descr *const descrs,
+                                                     struct argpar_iter *const iter,
+                                                     struct argpar_error **const error,
+                                                     struct argpar_item **const item)
 {
        enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
 
@@ -662,12 +639,10 @@ enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg,
 
        if (orig_arg[1] == '-') {
                /* Long option */
-               ret = parse_long_opt(&orig_arg[2],
-                       next_orig_arg, descrs, iter, error, item);
+               ret = parse_long_opt(&orig_arg[2], next_orig_arg, descrs, iter, error, item);
        } else {
                /* Short option */
-               ret = parse_short_opt_group(&orig_arg[1],
-                       next_orig_arg, descrs, iter, error, item);
+               ret = parse_short_opt_group(&orig_arg[1], next_orig_arg, descrs, iter, error, item);
        }
 
        return ret;
@@ -675,8 +650,8 @@ enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg,
 
 ARGPAR_HIDDEN
 struct argpar_iter *argpar_iter_create(const unsigned int argc,
-               const char * const * const argv,
-               const struct argpar_opt_descr * const descrs)
+                                      const char *const *const argv,
+                                      const struct argpar_opt_descr *const descrs)
 {
        struct argpar_iter *iter = ARGPAR_ZALLOC(struct argpar_iter);
 
@@ -700,7 +675,7 @@ end:
 }
 
 ARGPAR_HIDDEN
-void argpar_iter_destroy(struct argpar_iter * const iter)
+void argpar_iter_destroy(struct argpar_iter *const iter)
 {
        if (iter) {
                free(iter->tmp_buf.data);
@@ -709,16 +684,15 @@ void argpar_iter_destroy(struct argpar_iter * const iter)
 }
 
 ARGPAR_HIDDEN
-enum argpar_iter_next_status argpar_iter_next(
-               struct argpar_iter * const iter,
-               const struct argpar_item ** const item,
-               const struct argpar_error ** const error)
+enum argpar_iter_next_status argpar_iter_next(struct argpar_iter *const iter,
+                                             const struct argpar_item **const item,
+                                             const struct argpar_error **const error)
 {
        enum argpar_iter_next_status status;
        enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret;
        const char *orig_arg;
        const char *next_orig_arg;
-       struct argpar_error ** const nc_error = (struct argpar_error **) error;
+       struct argpar_error **const nc_error = (struct argpar_error **) error;
 
        ARGPAR_ASSERT(iter->i <= iter->user.argc);
 
@@ -732,16 +706,12 @@ enum argpar_iter_next_status argpar_iter_next(
        }
 
        orig_arg = iter->user.argv[iter->i];
-       next_orig_arg =
-               iter->i < (iter->user.argc - 1) ?
-                       iter->user.argv[iter->i + 1] : NULL;
+       next_orig_arg = iter->i < (iter->user.argc - 1) ? iter->user.argv[iter->i + 1] : NULL;
 
-       if (strcmp(orig_arg, "-") == 0 || strcmp(orig_arg, "--") == 0 ||
-                       orig_arg[0] != '-') {
+       if (strcmp(orig_arg, "-") == 0 || strcmp(orig_arg, "--") == 0 || orig_arg[0] != '-') {
                /* Non-option argument */
-               const struct argpar_item_non_opt * const non_opt_item =
-                       create_non_opt_item(orig_arg, iter->i,
-                               iter->non_opt_index);
+               const struct argpar_item_non_opt *const non_opt_item =
+                       create_non_opt_item(orig_arg, iter->i, iter->non_opt_index);
 
                if (!non_opt_item) {
                        status = ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY;
@@ -757,8 +727,11 @@ enum argpar_iter_next_status argpar_iter_next(
 
        /* Option argument */
        parse_orig_arg_opt_ret = parse_orig_arg_opt(orig_arg,
-               next_orig_arg, iter->user.descrs, iter, nc_error,
-               (struct argpar_item **) item);
+                                                   next_orig_arg,
+                                                   iter->user.descrs,
+                                                   iter,
+                                                   nc_error,
+                                                   (struct argpar_item **) item);
        switch (parse_orig_arg_opt_ret) {
        case PARSE_ORIG_ARG_OPT_RET_OK:
                status = ARGPAR_ITER_NEXT_STATUS_OK;
@@ -782,8 +755,7 @@ end:
 }
 
 ARGPAR_HIDDEN
-unsigned int argpar_iter_ingested_orig_args(
-               const struct argpar_iter * const iter)
+unsigned int argpar_iter_ingested_orig_args(const struct argpar_iter *const iter)
 {
        return iter->i;
 }