plugins/utils.c: clang-format

1 files changed, 201 insertions, 308 deletions

diff --git a/plugins/utils.c b/plugins/utils.c
index 77d6a6f9..1b88fa75 100644
--- a/plugins/utils.c
+++ b/plugins/utils.c
@@ -1,26 +1,26 @@
 /*****************************************************************************
-* 
-* Library of useful functions for plugins
-* 
-* License: GPL
-* Copyright (c) 2000 Karl DeBisschop (karl@debisschop.net)
-* Copyright (c) 2002-2007 Monitoring Plugins Development Team
-* 
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-* 
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-* 
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-* 
-* 
-*****************************************************************************/
+ *
+ * Library of useful functions for plugins
+ *
+ * License: GPL
+ * Copyright (c) 2000 Karl DeBisschop (karl@debisschop.net)
+ * Copyright (c) 2002-2007 Monitoring Plugins Development Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ *****************************************************************************/
 
 #include "common.h"
 #include "./utils.h"
@@ -34,7 +34,7 @@
 
 #include <arpa/inet.h>
 
-extern void print_usage (void);
+extern void print_usage(void);
 extern const char *progname;
 
 #define STRLEN 64
@@ -50,9 +50,7 @@ time_t start_time, end_time;
  * Note that numerically the above does not hold
  ****************************************************************************/
 
-int
-max_state (int a, int b)
-{
+int max_state(int a, int b) {
         if (a == STATE_CRITICAL || b == STATE_CRITICAL)
                 return STATE_CRITICAL;
         else if (a == STATE_WARNING || b == STATE_WARNING)
@@ -64,7 +62,7 @@ max_state (int a, int b)
         else if (a == STATE_DEPENDENT || b == STATE_DEPENDENT)
                 return STATE_DEPENDENT;
         else
-                return max (a, b);
+                return max(a, b);
 }
 
 /* **************************************************************************
@@ -77,9 +75,7 @@ max_state (int a, int b)
  * non-OK state.
  ****************************************************************************/
 
-int
-max_state_alt (int a, int b)
-{
+int max_state_alt(int a, int b) {
         if (a == STATE_CRITICAL || b == STATE_CRITICAL)
                 return STATE_CRITICAL;
         else if (a == STATE_WARNING || b == STATE_WARNING)
@@ -91,124 +87,112 @@ max_state_alt (int a, int b)
         else if (a == STATE_OK || b == STATE_OK)
                 return STATE_OK;
         else
-                return max (a, b);
+                return max(a, b);
 }
 
-void usage (const char *msg)
-{
-        printf ("%s\n", msg);
-        print_usage ();
-        exit (STATE_UNKNOWN);
+void usage(const char *msg) {
+        printf("%s\n", msg);
+        print_usage();
+        exit(STATE_UNKNOWN);
 }
 
-void usage_va (const char *fmt, ...)
-{
+void usage_va(const char *fmt, ...) {
         va_list ap;
         printf("%s: ", progname);
         va_start(ap, fmt);
         vprintf(fmt, ap);
         va_end(ap);
         printf("\n");
-        exit (STATE_UNKNOWN);
+        exit(STATE_UNKNOWN);
 }
 
-void usage2(const char *msg, const char *arg)
-{
-        printf ("%s: %s - %s\n", progname, msg, arg?arg:"(null)" );
-        print_usage ();
-        exit (STATE_UNKNOWN);
+void usage2(const char *msg, const char *arg) {
+        printf("%s: %s - %s\n", progname, msg, arg ? arg : "(null)");
+        print_usage();
+        exit(STATE_UNKNOWN);
 }
 
-void
-usage3 (const char *msg, int arg)
-{
-        printf ("%s: %s - %c\n", progname, msg, arg);
+void usage3(const char *msg, int arg) {
+        printf("%s: %s - %c\n", progname, msg, arg);
         print_usage();
-        exit (STATE_UNKNOWN);
+        exit(STATE_UNKNOWN);
 }
 
-void
-usage4 (const char *msg)
-{
-        printf ("%s: %s\n", progname, msg);
+void usage4(const char *msg) {
+        printf("%s: %s\n", progname, msg);
         print_usage();
-        exit (STATE_UNKNOWN);
+        exit(STATE_UNKNOWN);
 }
 
-void
-usage5 (void)
-{
+void usage5(void) {
         print_usage();
-        exit (STATE_UNKNOWN);
+        exit(STATE_UNKNOWN);
 }
 
-void
-print_revision (const char *command_name, const char *revision)
-{
-        printf ("%s v%s (%s %s)\n",
-                 command_name, revision, PACKAGE, VERSION);
+void print_revision(const char *command_name, const char *revision) {
+        printf("%s v%s (%s %s)\n", command_name, revision, PACKAGE, VERSION);
 }
 
-bool is_numeric (char *number) {
+bool is_numeric(char *number) {
         char tmp[1];
         float x;
 
         if (!number)
                 return false;
-        else if (sscanf (number, "%f%c", &x, tmp) == 1)
+        else if (sscanf(number, "%f%c", &x, tmp) == 1)
                 return true;
         else
                 return false;
 }
 
-bool is_positive (char *number) {
-        if (is_numeric (number) && atof (number) > 0.0)
+bool is_positive(char *number) {
+        if (is_numeric(number) && atof(number) > 0.0)
                 return true;
         else
                 return false;
 }
 
-bool is_negative (char *number) {
-        if (is_numeric (number) && atof (number) < 0.0)
+bool is_negative(char *number) {
+        if (is_numeric(number) && atof(number) < 0.0)
                 return true;
         else
                 return false;
 }
 
-bool is_nonnegative (char *number) {
-        if (is_numeric (number) && atof (number) >= 0.0)
+bool is_nonnegative(char *number) {
+        if (is_numeric(number) && atof(number) >= 0.0)
                 return true;
         else
                 return false;
 }
 
-bool is_percentage (char *number) {
+bool is_percentage(char *number) {
         int x;
-        if (is_numeric (number) && (x = atof (number)) >= 0 && x <= 100)
+        if (is_numeric(number) && (x = atof(number)) >= 0 && x <= 100)
                 return true;
         else
                 return false;
 }
 
-bool is_percentage_expression (const char str[]) {
+bool is_percentage_expression(const char str[]) {
         if (!str) {
                 return false;
         }
 
         size_t len = strlen(str);
 
-        if (str[len-1] != '%') {
+        if (str[len - 1] != '%') {
                 return false;
         }
 
         char *foo = calloc(sizeof(char), len + 1);
 
         if (!foo) {
-                die (STATE_UNKNOWN, _("calloc failed \n"));
+                die(STATE_UNKNOWN, _("calloc failed \n"));
         }
 
         strcpy(foo, str);
-        foo[len-1] = '\0';
+        foo[len - 1] = '\0';
 
         bool result = is_numeric(foo);
 
@@ -217,13 +201,13 @@ bool is_percentage_expression (const char str[]) {
         return result;
 }
 
-bool is_integer (char *number) {
+bool is_integer(char *number) {
         long int n;
 
-        if (!number || (strspn (number, "-0123456789 ") != strlen (number)))
+        if (!number || (strspn(number, "-0123456789 ") != strlen(number)))
                 return false;
 
-        n = strtol (number, NULL, 10);
+        n = strtol(number, NULL, 10);
 
         if (errno != ERANGE && n >= INT_MIN && n <= INT_MAX)
                 return true;
@@ -231,22 +215,22 @@ bool is_integer (char *number) {
                 return false;
 }
 
-bool is_intpos (char *number) {
-        if (is_integer (number) && atoi (number) > 0)
+bool is_intpos(char *number) {
+        if (is_integer(number) && atoi(number) > 0)
                 return true;
         else
                 return false;
 }
 
-bool is_intneg (char *number) {
-        if (is_integer (number) && atoi (number) < 0)
+bool is_intneg(char *number) {
+        if (is_integer(number) && atoi(number) < 0)
                 return true;
         else
                 return false;
 }
 
-bool is_intnonneg (char *number) {
-        if (is_integer (number) && atoi (number) >= 0)
+bool is_intnonneg(char *number) {
+        if (is_integer(number) && atoi(number) >= 0)
                 return true;
         else
                 return false;
@@ -259,7 +243,7 @@ bool is_intnonneg (char *number) {
  */
 bool is_int64(char *number, int64_t *target) {
         errno = 0;
-        char *endptr = { 0 };
+        char *endptr = {0};
 
         int64_t tmp = strtoll(number, &endptr, 10);
         if (errno != 0) {
@@ -287,7 +271,7 @@ bool is_int64(char *number, int64_t *target) {
  */
 bool is_uint64(char *number, uint64_t *target) {
         errno = 0;
-        char *endptr = { 0 };
+        char *endptr = {0};
         unsigned long long tmp = strtoull(number, &endptr, 10);
 
         if (errno != 0) {
@@ -309,66 +293,50 @@ bool is_uint64(char *number, uint64_t *target) {
         return true;
 }
 
-bool is_intpercent (char *number) {
+bool is_intpercent(char *number) {
         int i;
-        if (is_integer (number) && (i = atoi (number)) >= 0 && i <= 100)
+        if (is_integer(number) && (i = atoi(number)) >= 0 && i <= 100)
                 return true;
         else
                 return false;
 }
 
-bool is_option (char *str) {
+bool is_option(char *str) {
         if (!str)
                 return false;
-        else if (strspn (str, "-") == 1 || strspn (str, "-") == 2)
+        else if (strspn(str, "-") == 1 || strspn(str, "-") == 2)
                 return true;
         else
                 return false;
 }
 
 #ifdef NEED_GETTIMEOFDAY
-int
-gettimeofday (struct timeval *tv, struct timezone *tz)
-{
+int gettimeofday(struct timeval *tv, struct timezone *tz) {
         tv->tv_usec = 0;
-        tv->tv_sec = (long) time ((time_t) 0);
+        tv->tv_sec = (long)time((time_t)0);
 }
 #endif
 
-
-
-double
-delta_time (struct timeval tv)
-{
+double delta_time(struct timeval tv) {
         struct timeval now;
 
-        gettimeofday (&now, NULL);
+        gettimeofday(&now, NULL);
         return ((double)(now.tv_sec - tv.tv_sec) + (double)(now.tv_usec - tv.tv_usec) / (double)1000000);
 }
 
-
-
-long
-deltime (struct timeval tv)
-{
+long deltime(struct timeval tv) {
         struct timeval now;
-        gettimeofday (&now, NULL);
-        return (now.tv_sec - tv.tv_sec)*1000000 + now.tv_usec - tv.tv_usec;
+        gettimeofday(&now, NULL);
+        return (now.tv_sec - tv.tv_sec) * 1000000 + now.tv_usec - tv.tv_usec;
 }
 
-
-
-
-void
-strip (char *buffer)
-{
+void strip(char *buffer) {
         size_t x;
         int i;
 
-        for (x = strlen (buffer); x >= 1; x--) {
+        for (x = strlen(buffer); x >= 1; x--) {
                 i = x - 1;
-                if (buffer[i] == ' ' ||
-                                buffer[i] == '\r' || buffer[i] == '\n' || buffer[i] == '\t')
+                if (buffer[i] == ' ' || buffer[i] == '\r' || buffer[i] == '\n' || buffer[i] == '\t')
                         buffer[i] = '\0';
                 else
                         break;
@@ -376,7 +344,6 @@ strip (char *buffer)
         return;
 }
 
-
 /******************************************************************************
  *
  * Copies one string to another. Any previously existing data in
@@ -389,19 +356,15 @@ strip (char *buffer)
  *
  *****************************************************************************/
 
-char *
-strscpy (char *dest, const char *src)
-{
+char *strscpy(char *dest, const char *src) {
         if (src == NULL)
                 return NULL;
 
-        xasprintf (&dest, "%s", src);
+        xasprintf(&dest, "%s", src);
 
         return dest;
 }
 
-
-
 /******************************************************************************
  *
  * Returns a pointer to the next line of a multiline string buffer
@@ -418,7 +381,7 @@ strscpy (char *dest, const char *src)
  * This
  * is
  * a
- * 
+ *
  * multiline string buffer
  * ==============================
  *
@@ -431,7 +394,7 @@ strscpy (char *dest, const char *src)
  *   printf("%d %s",i++,firstword(ptr));
  *   ptr = strnl(ptr);
  * }
- * 
+ *
  * Produces the following:
  *
  * 1 This
@@ -452,25 +415,22 @@ strscpy (char *dest, const char *src)
  *
  *****************************************************************************/
 
-char *
-strnl (char *str)
-{
+char *strnl(char *str) {
         size_t len;
         if (str == NULL)
                 return NULL;
-        str = strpbrk (str, "\r\n");
+        str = strpbrk(str, "\r\n");
         if (str == NULL)
                 return NULL;
-        len = strspn (str, "\r\n");
+        len = strspn(str, "\r\n");
         if (str[len] == '\0')
                 return NULL;
         str += len;
-        if (strlen (str) == 0)
+        if (strlen(str) == 0)
                 return NULL;
         return str;
 }
 
-
 /******************************************************************************
  *
  * Like strscpy, except only the portion of the source string up to
@@ -487,29 +447,25 @@ strnl (char *str)
  *
  *****************************************************************************/
 
-char *
-strpcpy (char *dest, const char *src, const char *str)
-{
+char *strpcpy(char *dest, const char *src, const char *str) {
         size_t len;
 
         if (src)
-                len = strcspn (src, str);
+                len = strcspn(src, str);
         else
                 return NULL;
 
-        if (dest == NULL || strlen (dest) < len)
-                dest = realloc (dest, len + 1);
+        if (dest == NULL || strlen(dest) < len)
+                dest = realloc(dest, len + 1);
         if (dest == NULL)
-                die (STATE_UNKNOWN, _("failed realloc in strpcpy\n"));
+                die(STATE_UNKNOWN, _("failed realloc in strpcpy\n"));
 
-        strncpy (dest, src, len);
+        strncpy(dest, src, len);
         dest[len] = '\0';
 
         return dest;
 }
 
-
-
 /******************************************************************************
  *
  * Like strscat, except only the portion of the source string up to
@@ -518,62 +474,54 @@ strpcpy (char *dest, const char *src, const char *str)
  * str = strpcpy(str,"This is a line of text with no trailing newline","x");
  * str = strpcat(str,"This is a line of text with no trailing newline","x");
  * printf("%s\n",str);
- * 
+ *
  *This is a line of texThis is a line of tex
  *
  *****************************************************************************/
 
-char *
-strpcat (char *dest, const char *src, const char *str)
-{
+char *strpcat(char *dest, const char *src, const char *str) {
         size_t len, l2;
 
         if (dest)
-                len = strlen (dest);
+                len = strlen(dest);
         else
                 len = 0;
 
         if (src) {
-                l2 = strcspn (src, str);
-        }
-        else {
+                l2 = strcspn(src, str);
+        } else {
                 return dest;
         }
 
-        dest = realloc (dest, len + l2 + 1);
+        dest = realloc(dest, len + l2 + 1);
         if (dest == NULL)
-                die (STATE_UNKNOWN, _("failed malloc in strscat\n"));
+                die(STATE_UNKNOWN, _("failed malloc in strscat\n"));
 
-        strncpy (dest + len, src, l2);
+        strncpy(dest + len, src, l2);
         dest[len + l2] = '\0';
 
         return dest;
 }
 
-
 /******************************************************************************
  *
  * asprintf, but die on failure
  *
  ******************************************************************************/
 
-int
-xvasprintf (char **strp, const char *fmt, va_list ap)
-{
-        int result = vasprintf (strp, fmt, ap);
+int xvasprintf(char **strp, const char *fmt, va_list ap) {
+        int result = vasprintf(strp, fmt, ap);
         if (result == -1 || *strp == NULL)
-                die (STATE_UNKNOWN, _("failed malloc in xvasprintf\n"));
+                die(STATE_UNKNOWN, _("failed malloc in xvasprintf\n"));
         return result;
 }
 
-int
-xasprintf (char **strp, const char *fmt, ...)
-{
+int xasprintf(char **strp, const char *fmt, ...) {
         va_list ap;
         int result;
-        va_start (ap, fmt);
-        result = xvasprintf (strp, fmt, ap);
-        va_end (ap);
+        va_start(ap, fmt);
+        result = xvasprintf(strp, fmt, ap);
+        va_end(ap);
         return result;
 }
 
@@ -583,247 +531,192 @@ xasprintf (char **strp, const char *fmt, ...)
  *
  ******************************************************************************/
 
-char *perfdata (const char *label,
- long int val,
- const char *uom,
- int warnp,
- long int warn,
- int critp,
- long int crit,
- int minp,
- long int minv,
- int maxp,
- long int maxv)
-{
+char *perfdata(const char *label, long int val, const char *uom, int warnp, long int warn, int critp, long int crit, int minp,
+                           long int minv, int maxp, long int maxv) {
         char *data = NULL;
 
-        if (strpbrk (label, "'= "))
-                xasprintf (&data, "'%s'=%ld%s;", label, val, uom);
+        if (strpbrk(label, "'= "))
+                xasprintf(&data, "'%s'=%ld%s;", label, val, uom);
         else
-                xasprintf (&data, "%s=%ld%s;", label, val, uom);
+                xasprintf(&data, "%s=%ld%s;", label, val, uom);
 
         if (warnp)
-                xasprintf (&data, "%s%ld;", data, warn);
+                xasprintf(&data, "%s%ld;", data, warn);
         else
-                xasprintf (&data, "%s;", data);
+                xasprintf(&data, "%s;", data);
 
         if (critp)
-                xasprintf (&data, "%s%ld;", data, crit);
+                xasprintf(&data, "%s%ld;", data, crit);
         else
-                xasprintf (&data, "%s;", data);
+                xasprintf(&data, "%s;", data);
 
         if (minp)
-                xasprintf (&data, "%s%ld;", data, minv);
+                xasprintf(&data, "%s%ld;", data, minv);
         else
-                xasprintf (&data, "%s;", data);
+                xasprintf(&data, "%s;", data);
 
         if (maxp)
-                xasprintf (&data, "%s%ld", data, maxv);
+                xasprintf(&data, "%s%ld", data, maxv);
 
         return data;
 }
 
-
-char *perfdata_uint64 (const char *label,
- uint64_t val,
- const char *uom,
- int warnp, /* Warning present */
- uint64_t warn,
- int critp, /* Critical present */
- uint64_t crit,
- int minp, /* Minimum present */
- uint64_t minv,
- int maxp, /* Maximum present */
- uint64_t maxv)
-{
+char *perfdata_uint64(const char *label, uint64_t val, const char *uom, int warnp, /* Warning present */
+                                          uint64_t warn, int critp,                                    /* Critical present */
+                                          uint64_t crit, int minp,                                     /* Minimum present */
+                                          uint64_t minv, int maxp,                                     /* Maximum present */
+                                          uint64_t maxv) {
         char *data = NULL;
 
-        if (strpbrk (label, "'= "))
-                xasprintf (&data, "'%s'=%" PRIu64 "%s;", label, val, uom);
+        if (strpbrk(label, "'= "))
+                xasprintf(&data, "'%s'=%" PRIu64 "%s;", label, val, uom);
         else
-                xasprintf (&data, "%s=%" PRIu64 "%s;", label, val, uom);
+                xasprintf(&data, "%s=%" PRIu64 "%s;", label, val, uom);
 
         if (warnp)
-                xasprintf (&data, "%s%" PRIu64 ";", data, warn);
+                xasprintf(&data, "%s%" PRIu64 ";", data, warn);
         else
-                xasprintf (&data, "%s;", data);
+                xasprintf(&data, "%s;", data);
 
         if (critp)
-                xasprintf (&data, "%s%" PRIu64 ";", data, crit);
+                xasprintf(&data, "%s%" PRIu64 ";", data, crit);
         else
-                xasprintf (&data, "%s;", data);
+                xasprintf(&data, "%s;", data);
 
         if (minp)
-                xasprintf (&data, "%s%" PRIu64 ";", data, minv);
+                xasprintf(&data, "%s%" PRIu64 ";", data, minv);
         else
-                xasprintf (&data, "%s;", data);
+                xasprintf(&data, "%s;", data);
 
         if (maxp)
-                xasprintf (&data, "%s%" PRIu64, data, maxv);
+                xasprintf(&data, "%s%" PRIu64, data, maxv);
 
         return data;
 }
 
-
-char *perfdata_int64 (const char *label,
- int64_t val,
- const char *uom,
- int warnp, /* Warning present */
- int64_t warn,
- int critp, /* Critical present */
- int64_t crit,
- int minp, /* Minimum present */
- int64_t minv,
- int maxp, /* Maximum present */
- int64_t maxv)
-{
+char *perfdata_int64(const char *label, int64_t val, const char *uom, int warnp, /* Warning present */
+                                         int64_t warn, int critp,                                    /* Critical present */
+                                         int64_t crit, int minp,                                     /* Minimum present */
+                                         int64_t minv, int maxp,                                     /* Maximum present */
+                                         int64_t maxv) {
         char *data = NULL;
 
-        if (strpbrk (label, "'= "))
-                xasprintf (&data, "'%s'=%" PRId64 "%s;", label, val, uom);
+        if (strpbrk(label, "'= "))
+                xasprintf(&data, "'%s'=%" PRId64 "%s;", label, val, uom);
         else
-                xasprintf (&data, "%s=%" PRId64 "%s;", label, val, uom);
+                xasprintf(&data, "%s=%" PRId64 "%s;", label, val, uom);
 
         if (warnp)
-                xasprintf (&data, "%s%" PRId64 ";", data, warn);
+                xasprintf(&data, "%s%" PRId64 ";", data, warn);
         else
-                xasprintf (&data, "%s;", data);
+                xasprintf(&data, "%s;", data);
 
         if (critp)
-                xasprintf (&data, "%s%" PRId64 ";", data, crit);
+                xasprintf(&data, "%s%" PRId64 ";", data, crit);
         else
-                xasprintf (&data, "%s;", data);
+                xasprintf(&data, "%s;", data);
 
         if (minp)
-                xasprintf (&data, "%s%" PRId64 ";", data, minv);
+                xasprintf(&data, "%s%" PRId64 ";", data, minv);
         else
-                xasprintf (&data, "%s;", data);
+                xasprintf(&data, "%s;", data);
 
         if (maxp)
-                xasprintf (&data, "%s%" PRId64, data, maxv);
+                xasprintf(&data, "%s%" PRId64, data, maxv);
 
         return data;
 }
 
-
-char *fperfdata (const char *label,
- double val,
- const char *uom,
- int warnp,
- double warn,
- int critp,
- double crit,
- int minp,
- double minv,
- int maxp,
- double maxv)
-{
+char *fperfdata(const char *label, double val, const char *uom, int warnp, double warn, int critp, double crit, int minp, double minv,
+                                int maxp, double maxv) {
         char *data = NULL;
 
-        if (strpbrk (label, "'= "))
-                xasprintf (&data, "'%s'=", label);
+        if (strpbrk(label, "'= "))
+                xasprintf(&data, "'%s'=", label);
         else
-                xasprintf (&data, "%s=", label);
+                xasprintf(&data, "%s=", label);
 
-        xasprintf (&data, "%s%f", data, val);
-        xasprintf (&data, "%s%s;", data, uom);
+        xasprintf(&data, "%s%f", data, val);
+        xasprintf(&data, "%s%s;", data, uom);
 
         if (warnp)
-                xasprintf (&data, "%s%f", data, warn);
+                xasprintf(&data, "%s%f", data, warn);
 
-        xasprintf (&data, "%s;", data);
+        xasprintf(&data, "%s;", data);
 
         if (critp)
-                xasprintf (&data, "%s%f", data, crit);
+                xasprintf(&data, "%s%f", data, crit);
 
-        xasprintf (&data, "%s;", data);
+        xasprintf(&data, "%s;", data);
 
         if (minp)
-                xasprintf (&data, "%s%f", data, minv);
+                xasprintf(&data, "%s%f", data, minv);
 
         if (maxp) {
-                xasprintf (&data, "%s;", data);
-                xasprintf (&data, "%s%f", data, maxv);
+                xasprintf(&data, "%s;", data);
+                xasprintf(&data, "%s%f", data, maxv);
         }
 
         return data;
 }
 
-char *sperfdata (const char *label,
- double val,
- const char *uom,
- char *warn,
- char *crit,
- int minp,
- double minv,
- int maxp,
- double maxv)
-{
+char *sperfdata(const char *label, double val, const char *uom, char *warn, char *crit, int minp, double minv, int maxp, double maxv) {
         char *data = NULL;
-        if (strpbrk (label, "'= "))
-                xasprintf (&data, "'%s'=", label);
+        if (strpbrk(label, "'= "))
+                xasprintf(&data, "'%s'=", label);
         else
-                xasprintf (&data, "%s=", label);
+                xasprintf(&data, "%s=", label);
 
-        xasprintf (&data, "%s%f", data, val);
-        xasprintf (&data, "%s%s;", data, uom);
+        xasprintf(&data, "%s%f", data, val);
+        xasprintf(&data, "%s%s;", data, uom);
 
-        if (warn!=NULL)
-                xasprintf (&data, "%s%s", data, warn);
+        if (warn != NULL)
+                xasprintf(&data, "%s%s", data, warn);
 
-        xasprintf (&data, "%s;", data);
+        xasprintf(&data, "%s;", data);
 
-        if (crit!=NULL)
-                xasprintf (&data, "%s%s", data, crit);
+        if (crit != NULL)
+                xasprintf(&data, "%s%s", data, crit);
 
-        xasprintf (&data, "%s;", data);
+        xasprintf(&data, "%s;", data);
 
         if (minp)
-                xasprintf (&data, "%s%f", data, minv);
+                xasprintf(&data, "%s%f", data, minv);
 
         if (maxp) {
-                xasprintf (&data, "%s;", data);
-                xasprintf (&data, "%s%f", data, maxv);
+                xasprintf(&data, "%s;", data);
+                xasprintf(&data, "%s%f", data, maxv);
         }
 
         return data;
 }
 
-char *sperfdata_int (const char *label,
- int val,
- const char *uom,
- char *warn,
- char *crit,
- int minp,
- int minv,
- int maxp,
- int maxv)
-{
+char *sperfdata_int(const char *label, int val, const char *uom, char *warn, char *crit, int minp, int minv, int maxp, int maxv) {
         char *data = NULL;
-        if (strpbrk (label, "'= "))
-                xasprintf (&data, "'%s'=", label);
+        if (strpbrk(label, "'= "))
+                xasprintf(&data, "'%s'=", label);
         else
-                xasprintf (&data, "%s=", label);
+                xasprintf(&data, "%s=", label);
 
-        xasprintf (&data, "%s%d", data, val);
-        xasprintf (&data, "%s%s;", data, uom);
+        xasprintf(&data, "%s%d", data, val);
+        xasprintf(&data, "%s%s;", data, uom);
 
-        if (warn!=NULL)
-                xasprintf (&data, "%s%s", data, warn);
+        if (warn != NULL)
+                xasprintf(&data, "%s%s", data, warn);
 
-        xasprintf (&data, "%s;", data);
+        xasprintf(&data, "%s;", data);
 
-        if (crit!=NULL)
-                xasprintf (&data, "%s%s", data, crit);
+        if (crit != NULL)
+                xasprintf(&data, "%s%s", data, crit);
 
-        xasprintf (&data, "%s;", data);
+        xasprintf(&data, "%s;", data);
 
         if (minp)
-                xasprintf (&data, "%s%d", data, minv);
+                xasprintf(&data, "%s%d", data, minv);
 
         if (maxp) {
-                xasprintf (&data, "%s;", data);
-                xasprintf (&data, "%s%d", data, maxv);
+                xasprintf(&data, "%s;", data);
+                xasprintf(&data, "%s%d", data, maxv);
         }
 
         return data;