argpar/argpar.{c,h}: fix coding style

Add missing `const`, use uppercase macro names, fix comments, fix names
of local functions.

Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I18c7a2b1d5572f6b696c72f0cfa12b68c1c5f949

diff --git a/argpar/argpar.c b/argpar/argpar.c
index 9e3ab7625c6f5d6f51e05d98b7d872ddcbea9da8..4458d9a640efc3e51e85052f13bc0cf6d09a6969 100644 (file)
--- a/argpar/argpar.c
+++ b/argpar/argpar.c
@@ -14,9 +14,13 @@
 
 #include "argpar.h"
 
 
 #include "argpar.h"
 

-#define argpar_realloc(_ptr, _type, _nmemb) ((_type *) realloc(_ptr, (_nmemb) * sizeof(_type)))
-#define argpar_calloc(_type, _nmemb) ((_type *) calloc((_nmemb), sizeof(_type)))
-#define argpar_zalloc(_type) argpar_calloc(_type, 1)
+#define ARGPAR_REALLOC(_ptr, _type, _nmemb)                            \
+       ((_type *) realloc(_ptr, (_nmemb) * sizeof(_type)))
+
+#define ARGPAR_CALLOC(_type, _nmemb)                                   \
+       ((_type *) calloc((_nmemb), sizeof(_type)))
+
+#define ARGPAR_ZALLOC(_type) ARGPAR_CALLOC(_type, 1)

 
 #define ARGPAR_ASSERT(_cond) assert(_cond)
 
 
 #define ARGPAR_ASSERT(_cond) assert(_cond)
 


@@ -60,14 +64,13 @@ struct argpar_iter {
 };
 
 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 0)))
 };
 
 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 0)))

-char *argpar_vasprintf(const char *fmt, va_list args)
+char *argpar_vasprintf(const char * const fmt, va_list args)

 {
        int len1, len2;
        char *str;
        va_list args2;
 
        va_copy(args2, args);
 {
        int len1, len2;
        char *str;
        va_list args2;
 
        va_copy(args2, args);

-

        len1 = vsnprintf(NULL, 0, fmt, args);
        if (len1 < 0) {
                str = NULL;
        len1 = vsnprintf(NULL, 0, fmt, args);
        if (len1 < 0) {
                str = NULL;


@@ -80,7 +83,6 @@ char *argpar_vasprintf(const char *fmt, va_list args)
        }
 
        len2 = vsnprintf(str, len1 + 1, fmt, args2);
        }
 
        len2 = vsnprintf(str, len1 + 1, fmt, args2);

-

        ARGPAR_ASSERT(len1 == len2);
 
 end:
        ARGPAR_ASSERT(len1 == len2);
 
 end:


@@ -90,7 +92,7 @@ end:
 
 
 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 2)))
 
 
 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 2)))

-char *argpar_asprintf(const char *fmt, ...)
+char *argpar_asprintf(const char * const fmt, ...)

 {
        va_list args;
        char *str;
 {
        va_list args;
        char *str;


@@ -98,12 +100,11 @@ char *argpar_asprintf(const char *fmt, ...)
        va_start(args, fmt);
        str = argpar_vasprintf(fmt, args);
        va_end(args);
        va_start(args, fmt);
        str = argpar_vasprintf(fmt, args);
        va_end(args);

-

        return str;
 }
 
 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 2, 3)))
        return str;
 }
 
 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 2, 3)))

-bool argpar_string_append_printf(char **str, const char *fmt, ...)
+bool append_string_printf(char ** const str, const char *fmt, ...)

 {
        char *new_str = NULL;
        char *addendum;
 {
        char *new_str = NULL;
        char *addendum;


@@ -111,7 +112,6 @@ bool argpar_string_append_printf(char **str, const char *fmt, ...)
        va_list args;
 
        ARGPAR_ASSERT(str);
        va_list args;
 
        ARGPAR_ASSERT(str);

-

        va_start(args, fmt);
        addendum = argpar_vasprintf(fmt, args);
        va_end(args);
        va_start(args, fmt);
        addendum = argpar_vasprintf(fmt, args);
        va_end(args);


@@ -129,12 +129,10 @@ bool argpar_string_append_printf(char **str, const char *fmt, ...)
 
        free(*str);
        *str = new_str;
 
        free(*str);
        *str = new_str;

-

        success = true;
 
 end:
        free(addendum);
        success = true;
 
 end:
        free(addendum);

-

        return success;
 }
 
        return success;
 }
 


@@ -160,7 +158,7 @@ end:
 
 static
 bool push_item(struct argpar_item_array * const array,
 
 static
 bool push_item(struct argpar_item_array * const array,

-               struct argpar_item * const item)
+               const struct argpar_item * const item)

 {
        bool success;
 
 {
        bool success;
 


@@ -168,11 +166,10 @@ bool push_item(struct argpar_item_array * const array,
        ARGPAR_ASSERT(item);
 
        if (array->n_items == array->n_alloc) {
        ARGPAR_ASSERT(item);
 
        if (array->n_items == array->n_alloc) {

-               unsigned int new_n_alloc = array->n_alloc * 2;
-               struct argpar_item **new_items;
-
-               new_items = argpar_realloc(array->items,
-                       struct argpar_item *, new_n_alloc);
+               const unsigned int new_n_alloc = array->n_alloc * 2;
+               const struct argpar_item ** const new_items =
+                       ARGPAR_REALLOC(array->items, const struct argpar_item *,
+                               new_n_alloc);

                if (!new_items) {
                        success = false;
                        goto end;
                if (!new_items) {
                        success = false;
                        goto end;


@@ -184,7 +181,6 @@ bool push_item(struct argpar_item_array * const array,
 
        array->items[array->n_items] = item;
        array->n_items++;
 
        array->items[array->n_items] = item;
        array->n_items++;

-

        success = true;
 
 end:
        success = true;
 
 end:


@@ -207,23 +203,22 @@ void destroy_item_array(struct argpar_item_array * const array)
 }
 
 static
 }
 
 static

-struct argpar_item_array *new_item_array(void)
+struct argpar_item_array *create_item_array(void)

 {
        struct argpar_item_array *ret;
        const int initial_size = 10;
 
 {
        struct argpar_item_array *ret;
        const int initial_size = 10;
 

-       ret = argpar_zalloc(struct argpar_item_array);
+       ret = ARGPAR_ZALLOC(struct argpar_item_array);

        if (!ret) {
                goto end;
        }
 
        if (!ret) {
                goto end;
        }
 

-       ret->items = argpar_calloc(struct argpar_item *, initial_size);
+       ret->items = ARGPAR_CALLOC(const struct argpar_item *, initial_size);

        if (!ret->items) {
                goto error;
        }
 
        ret->n_alloc = initial_size;
        if (!ret->items) {
                goto error;
        }
 
        ret->n_alloc = initial_size;

-

        goto end;
 
 error:
        goto end;
 
 error:


@@ -240,7 +235,7 @@ struct argpar_item_opt *create_opt_item(
                const char * const arg)
 {
        struct argpar_item_opt *opt_item =
                const char * const arg)
 {
        struct argpar_item_opt *opt_item =

-               argpar_zalloc(struct argpar_item_opt);
+               ARGPAR_ZALLOC(struct argpar_item_opt);

 
        if (!opt_item) {
                goto end;
 
        if (!opt_item) {
                goto end;


@@ -272,7 +267,7 @@ struct argpar_item_non_opt *create_non_opt_item(const char * const arg,
                const unsigned int non_opt_index)
 {
        struct argpar_item_non_opt * const non_opt_item =
                const unsigned int non_opt_index)
 {
        struct argpar_item_non_opt * const non_opt_item =

-               argpar_zalloc(struct argpar_item_non_opt);
+               ARGPAR_ZALLOC(struct argpar_item_non_opt);

 
        if (!non_opt_item) {
                goto end;
 
        if (!non_opt_item) {
                goto end;


@@ -330,7 +325,7 @@ enum parse_orig_arg_opt_ret parse_short_opts(const char * const short_opts,
        struct argpar_item_opt *opt_item;
 
        if (strlen(short_opts) == 0) {
        struct argpar_item_opt *opt_item;
 
        if (strlen(short_opts) == 0) {

-               argpar_string_append_printf(error, "Invalid argument");
+               append_string_printf(error, "Invalid argument");

                goto error;
        }
 
                goto error;
        }
 


@@ -342,8 +337,8 @@ enum parse_orig_arg_opt_ret parse_short_opts(const char * const short_opts,
        descr = find_descr(descrs, *iter->short_opt_ch, NULL);
        if (!descr) {
                ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
        descr = find_descr(descrs, *iter->short_opt_ch, NULL);
        if (!descr) {
                ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;

-               argpar_string_append_printf(error,
-                       "Unknown option `-%c`", *iter->short_opt_ch);
+               append_string_printf(error, "Unknown option `-%c`",
+                       *iter->short_opt_ch);

                goto error;
        }
 
                goto error;
        }
 


@@ -361,8 +356,9 @@ enum parse_orig_arg_opt_ret parse_short_opts(const char * const short_opts,
                 * We accept `-o ''` (empty option argument), but not
                 * `-o` alone if an option argument is expected.
                 */
                 * We accept `-o ''` (empty option argument), but not
                 * `-o` alone if an option argument is expected.
                 */

-               if (!opt_arg || (iter->short_opt_ch[1] && strlen(opt_arg) == 0)) {
-                       argpar_string_append_printf(error,
+               if (!opt_arg || (iter->short_opt_ch[1] &&
+                               strlen(opt_arg) == 0)) {
+                       append_string_printf(error,

                                "Missing required argument for option `-%c`",
                                *iter->short_opt_ch);
                        used_next_orig_arg = false;
                                "Missing required argument for option `-%c`",
                                *iter->short_opt_ch);
                        used_next_orig_arg = false;


@@ -427,7 +423,7 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
        const char *long_opt_name = long_opt_arg;
 
        if (strlen(long_opt_arg) == 0) {
        const char *long_opt_name = long_opt_arg;
 
        if (strlen(long_opt_arg) == 0) {

-               argpar_string_append_printf(error, "Invalid argument");
+               append_string_printf(error, "Invalid argument");

                goto error;
        }
 
                goto error;
        }
 


@@ -438,8 +434,8 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
 
                /* Isolate the option name */
                if (long_opt_name_size > max_len) {
 
                /* Isolate the option name */
                if (long_opt_name_size > max_len) {

-                       argpar_string_append_printf(error,
-                               "Invalid argument `--%s`", long_opt_arg);
+                       append_string_printf(error, "Invalid argument `--%s`",
+                               long_opt_arg);

                        goto error;
                }
 
                        goto error;
                }
 


@@ -451,8 +447,8 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
        /* Find corresponding option descriptor */
        descr = find_descr(descrs, '\0', long_opt_name);
        if (!descr) {
        /* Find corresponding option descriptor */
        descr = find_descr(descrs, '\0', long_opt_name);
        if (!descr) {

-               argpar_string_append_printf(error,
-                       "Unknown option `--%s`", long_opt_name);
+               append_string_printf(error, "Unknown option `--%s`",
+                       long_opt_name);

                ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
                goto error;
        }
                ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
                goto error;
        }


@@ -465,7 +461,7 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
                } else {
                        /* `--long-opt arg` style */
                        if (!next_orig_arg) {
                } else {
                        /* `--long-opt arg` style */
                        if (!next_orig_arg) {

-                               argpar_string_append_printf(error,
+                               append_string_printf(error,

                                        "Missing required argument for option `--%s`",
                                        long_opt_name);
                                goto error;
                                        "Missing required argument for option `--%s`",
                                        long_opt_name);
                                goto error;


@@ -479,7 +475,7 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
                 * Unexpected `--opt=arg` style for a long option which
                 * doesn't accept an argument.
                 */
                 * Unexpected `--opt=arg` style for a long option which
                 * doesn't accept an argument.
                 */

-               argpar_string_append_printf(error,
+               append_string_printf(error,

                        "Unexpected argument for option `--%s`", long_opt_name);
                goto error;
        }
                        "Unexpected argument for option `--%s`", long_opt_name);
                goto error;
        }


@@ -512,8 +508,7 @@ 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,
 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,
-               char ** const error,
+               struct argpar_iter * const iter, char ** const error,

                struct argpar_item ** const item)
 {
        enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
                struct argpar_item ** const item)
 {
        enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;


@@ -534,7 +529,7 @@ enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg,
 }
 
 static
 }
 
 static

-bool prepend_while_parsing_arg_to_error(char **error,
+bool prepend_while_parsing_arg_to_error(char ** const error,

                const unsigned int i, const char * const arg)
 {
        char *new_error;
                const unsigned int i, const char * const arg)
 {
        char *new_error;


@@ -542,7 +537,6 @@ bool prepend_while_parsing_arg_to_error(char **error,
 
        ARGPAR_ASSERT(error);
        ARGPAR_ASSERT(*error);
 
        ARGPAR_ASSERT(error);
        ARGPAR_ASSERT(*error);

-

        new_error = argpar_asprintf("While parsing argument #%u (`%s`): %s",
                i + 1, arg, *error);
        if (!new_error) {
        new_error = argpar_asprintf("While parsing argument #%u (`%s`): %s",
                i + 1, arg, *error);
        if (!new_error) {


@@ -563,7 +557,7 @@ 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 * const iter = argpar_zalloc(struct argpar_iter);
+       struct argpar_iter * const iter = ARGPAR_ZALLOC(struct argpar_iter);

 
        if (!iter) {
                goto end;
 
        if (!iter) {
                goto end;


@@ -586,8 +580,7 @@ void argpar_iter_destroy(struct argpar_iter * const iter)
 ARGPAR_HIDDEN
 enum argpar_iter_parse_next_status argpar_iter_parse_next(
                struct argpar_iter * const iter,
 ARGPAR_HIDDEN
 enum argpar_iter_parse_next_status argpar_iter_parse_next(
                struct argpar_iter * const iter,

-               const struct argpar_item ** const item,
-               char ** const error)
+               const struct argpar_item ** const item, char ** const error)

 {
        enum argpar_iter_parse_next_status status;
        enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret;
 {
        enum argpar_iter_parse_next_status status;
        enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret;


@@ -665,7 +658,7 @@ struct argpar_parse_ret argpar_parse(const unsigned int argc,
        const struct argpar_item *item = NULL;
        struct argpar_iter *iter = NULL;
 
        const struct argpar_item *item = NULL;
        struct argpar_iter *iter = NULL;
 

-       parse_ret.items = new_item_array();
+       parse_ret.items = create_item_array();

        if (!parse_ret.items) {
                parse_ret.error = strdup("Failed to create items array.");
                ARGPAR_ASSERT(parse_ret.error);
        if (!parse_ret.items) {
                parse_ret.error = strdup("Failed to create items array.");
                ARGPAR_ASSERT(parse_ret.error);


@@ -680,9 +673,9 @@ struct argpar_parse_ret argpar_parse(const unsigned int argc,
        }
 
        while (true) {
        }
 
        while (true) {

-               enum argpar_iter_parse_next_status status;
+               const enum argpar_iter_parse_next_status status =
+                       argpar_iter_parse_next(iter, &item, &parse_ret.error);

 
 

-               status = argpar_iter_parse_next(iter, &item, &parse_ret.error);

                if (status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR) {
                        goto error;
                } else if (status == ARGPAR_ITER_PARSE_NEXT_STATUS_END) {
                if (status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR) {
                        goto error;
                } else if (status == ARGPAR_ITER_PARSE_NEXT_STATUS_END) {


@@ -701,7 +694,7 @@ struct argpar_parse_ret argpar_parse(const unsigned int argc,
 
                ARGPAR_ASSERT(status == ARGPAR_ITER_PARSE_NEXT_STATUS_OK);
 
 
                ARGPAR_ASSERT(status == ARGPAR_ITER_PARSE_NEXT_STATUS_OK);
 

-               if (!push_item(parse_ret.items, (void *) item)) {
+               if (!push_item(parse_ret.items, item)) {

                        goto error;
                }
 
                        goto error;
                }
 


@@ -709,8 +702,7 @@ struct argpar_parse_ret argpar_parse(const unsigned int argc,
        }
 
        ARGPAR_ASSERT(!parse_ret.error);
        }
 
        ARGPAR_ASSERT(!parse_ret.error);

-       parse_ret.ingested_orig_args =
-               argpar_iter_get_ingested_orig_args(iter);
+       parse_ret.ingested_orig_args = argpar_iter_get_ingested_orig_args(iter);

        goto end;
 
 error:
        goto end;
 
 error:


@@ -727,13 +719,11 @@ end:
 }
 
 ARGPAR_HIDDEN
 }
 
 ARGPAR_HIDDEN

-void argpar_parse_ret_fini(struct argpar_parse_ret *ret)
+void argpar_parse_ret_fini(struct argpar_parse_ret * const ret)

 {
        ARGPAR_ASSERT(ret);
 {
        ARGPAR_ASSERT(ret);

-

        destroy_item_array(ret->items);
        ret->items = NULL;
        destroy_item_array(ret->items);
        ret->items = NULL;

-

        free(ret->error);
        ret->error = NULL;
 }
        free(ret->error);
        ret->error = NULL;
 }

diff --git a/argpar/argpar.h b/argpar/argpar.h
index 45dd84ed9d493d0bfb5208bfada2a7ed25750938..6ebc845e69cec679df268c464dfc8b19a161e166 100644 (file)
--- a/argpar/argpar.h
+++ b/argpar/argpar.h
@@ -105,16 +105,16 @@
 #define ARGPAR_OPT_DESCR_SENTINEL      { -1, '\0', NULL, false }
 
 /*
 #define ARGPAR_OPT_DESCR_SENTINEL      { -1, '\0', NULL, false }
 
 /*

- * ARGPAR_HIDDEN: if argpar is used in some shared library, we don't
- * want them to be exported by that library, so mark them as "hidden".
+ * If argpar is used in some shared library, we don't want said library
+ * to export its symbols, so mark them as "hidden".

  *
  * On Windows, symbols are local unless explicitly exported; see
  * <https://gcc.gnu.org/wiki/Visibility>.
  */
 #if defined(_WIN32) || defined(__CYGWIN__)
  *
  * On Windows, symbols are local unless explicitly exported; see
  * <https://gcc.gnu.org/wiki/Visibility>.
  */
 #if defined(_WIN32) || defined(__CYGWIN__)

-#define ARGPAR_HIDDEN
+# define ARGPAR_HIDDEN

 #else
 #else

-#define ARGPAR_HIDDEN __attribute__((visibility("hidden")))
+# define ARGPAR_HIDDEN __attribute__((visibility("hidden")))

 #endif
 
 /* Forward-declaration for the opaque type */
 #endif
 
 /* Forward-declaration for the opaque type */


@@ -178,20 +178,19 @@ struct argpar_item_non_opt {
 };
 
 struct argpar_item_array {
 };
 
 struct argpar_item_array {

-       /* Array of `struct argpar_item *`, or `NULL` on error */
-       struct argpar_item **items;
+       const struct argpar_item **items;

 
 

-       /* Number of used slots in `items`. */
+       /* Number of used slots in `items` */

        unsigned int n_items;
 
        unsigned int n_items;
 

-       /* Number of allocated slots in `items`. */
+       /* Number of allocated slots in `items` */

        unsigned int n_alloc;
 };
 
 /* What is returned by argpar_parse() */
 struct argpar_parse_ret {
        /*
        unsigned int n_alloc;
 };
 
 /* What is returned by argpar_parse() */
 struct argpar_parse_ret {
        /*

-        * Array of `struct argpar_item *`, or `NULL` on error.
+        * Array of parsing items, or `NULL` on error.

         *
         * Do NOT destroy those items manually with
         * argpar_iter_destroy(): call argpar_parse_ret_fini() to
         *
         * Do NOT destroy those items manually with
         * argpar_iter_destroy(): call argpar_parse_ret_fini() to


@@ -340,10 +339,10 @@ void argpar_item_destroy(const struct argpar_item *item);
  * Destroys `_item` (`const struct argpar_item *`) and sets it to
  * `NULL`.
  */
  * Destroys `_item` (`const struct argpar_item *`) and sets it to
  * `NULL`.
  */

-#define ARGPAR_ITEM_DESTROY_AND_RESET(_item)   \
-       {                                       \
-               argpar_item_destroy(_item);     \
-               _item = NULL;                   \
+#define ARGPAR_ITEM_DESTROY_AND_RESET(_item)                           \
+       {                                                               \
+               argpar_item_destroy(_item);                             \
+               _item = NULL;                                           \

        }
 
 #endif /* BABELTRACE_ARGPAR_H */
        }
 
 #endif /* BABELTRACE_ARGPAR_H */