*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 339 insertions, 369 deletions

diff --git a/lldb/source/Host/common/GetOptInc.cpp b/lldb/source/Host/common/GetOptInc.cpp
index 7689f36c815..231e9916a9d 100644
--- a/lldb/source/Host/common/GetOptInc.cpp
+++ b/lldb/source/Host/common/GetOptInc.cpp
@@ -1,6 +1,7 @@
 #include "lldb/Host/common/GetOptInc.h"
 
-#if defined(REPLACE_GETOPT) || defined(REPLACE_GETOPT_LONG) || defined(REPLACE_GETOPT_LONG_ONLY)
+#if defined(REPLACE_GETOPT) || defined(REPLACE_GETOPT_LONG) ||                 \
+    defined(REPLACE_GETOPT_LONG_ONLY)
 
 // getopt.cpp
 #include <errno.h>
@@ -8,32 +9,32 @@
 #include <string.h>
 
 #if defined(REPLACE_GETOPT)
-int opterr = 1;     /* if error message should be printed */
-int optind = 1;     /* index into parent argv vector */
-int optopt = '?';   /* character checked for validity */
-int optreset;       /* reset getopt */
-char *optarg;       /* argument associated with option */
+int opterr = 1;   /* if error message should be printed */
+int optind = 1;   /* index into parent argv vector */
+int optopt = '?'; /* character checked for validity */
+int optreset;     /* reset getopt */
+char *optarg;     /* argument associated with option */
 #endif
 
 #define PRINT_ERROR ((opterr) && (*options != ':'))
 
-#define FLAG_PERMUTE    0x01    /* permute non-options to the end of argv */
-#define FLAG_ALLARGS    0x02    /* treat non-options as args to option "-1" */
-#define FLAG_LONGONLY   0x04    /* operate as getopt_long_only */
+#define FLAG_PERMUTE 0x01  /* permute non-options to the end of argv */
+#define FLAG_ALLARGS 0x02  /* treat non-options as args to option "-1" */
+#define FLAG_LONGONLY 0x04 /* operate as getopt_long_only */
 
 /* return values */
-#define BADCH       (int)'?'
-#define BADARG      ((*options == ':') ? (int)':' : (int)'?')
-#define INORDER     (int)1
+#define BADCH (int)'?'
+#define BADARG ((*options == ':') ? (int)':' : (int)'?')
+#define INORDER (int)1
 
-#define EMSG        ""
+#define EMSG ""
 
-static int getopt_internal(int, char * const *, const char *,
-    const struct option *, int *, int);
-static int parse_long_options(char * const *, const char *,
-    const struct option *, int *, int);
+static int getopt_internal(int, char *const *, const char *,
+                           const struct option *, int *, int);
+static int parse_long_options(char *const *, const char *,
+                              const struct option *, int *, int);
 static int gcd(int, int);
-static void permute_args(int, int, int, char * const *);
+static void permute_args(int, int, int, char *const *);
 
 static const char *place = EMSG; /* option letter processing */
 
@@ -44,19 +45,17 @@ static int nonopt_end = -1;   /* first option after non options (for permute) */
 /*
 * Compute the greatest common divisor of a and b.
 */
-static int
-gcd(int a, int b)
-{
-    int c;
+static int gcd(int a, int b) {
+  int c;
 
+  c = a % b;
+  while (c != 0) {
+    a = b;
+    b = c;
     c = a % b;
-    while (c != 0) {
-        a = b;
-        b = c;
-        c = a % b;
-    }
+  }
 
-    return (b);
+  return (b);
 }
 
 static void pass() {}
@@ -67,36 +66,34 @@ static void pass() {}
 * from nonopt_end to opt_end (keeping the same order of arguments
 * in each block).
 */
-static void
-permute_args(int panonopt_start, int panonopt_end, int opt_end,
-char * const *nargv)
-{
-    int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
-    char *swap;
-
-    /*
-    * compute lengths of blocks and number and size of cycles
-    */
-    nnonopts = panonopt_end - panonopt_start;
-    nopts = opt_end - panonopt_end;
-    ncycle = gcd(nnonopts, nopts);
-    cyclelen = (opt_end - panonopt_start) / ncycle;
-
-    for (i = 0; i < ncycle; i++) {
-        cstart = panonopt_end + i;
-        pos = cstart;
-        for (j = 0; j < cyclelen; j++) {
-            if (pos >= panonopt_end)
-                pos -= nnonopts;
-            else
-                pos += nopts;
-            swap = nargv[pos];
-            /* LINTED const cast */
-            ((char **)nargv)[pos] = nargv[cstart];
-            /* LINTED const cast */
-            ((char **)nargv)[cstart] = swap;
-        }
+static void permute_args(int panonopt_start, int panonopt_end, int opt_end,
+                         char *const *nargv) {
+  int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+  char *swap;
+
+  /*
+  * compute lengths of blocks and number and size of cycles
+  */
+  nnonopts = panonopt_end - panonopt_start;
+  nopts = opt_end - panonopt_end;
+  ncycle = gcd(nnonopts, nopts);
+  cyclelen = (opt_end - panonopt_start) / ncycle;
+
+  for (i = 0; i < ncycle; i++) {
+    cstart = panonopt_end + i;
+    pos = cstart;
+    for (j = 0; j < cyclelen; j++) {
+      if (pos >= panonopt_end)
+        pos -= nnonopts;
+      else
+        pos += nopts;
+      swap = nargv[pos];
+      /* LINTED const cast */
+      ((char **)nargv)[pos] = nargv[cstart];
+      /* LINTED const cast */
+      ((char **)nargv)[cstart] = swap;
     }
+  }
 }
 
 /*
@@ -104,318 +101,297 @@ char * const *nargv)
 *  Parse long options in argc/argv argument vector.
 * Returns -1 if short_too is set and the option does not match long_options.
 */
-static int
-parse_long_options(char * const *nargv, const char *options,
-const struct option *long_options, int *idx, int short_too)
-{
-    char *current_argv, *has_equal;
-    size_t current_argv_len;
-    int i, match;
-
-    current_argv = const_cast<char*>(place);
-    match = -1;
-
-    optind++;
-
-    if ((has_equal = strchr(current_argv, '=')) != NULL) {
-        /* argument found (--option=arg) */
-        current_argv_len = has_equal - current_argv;
-        has_equal++;
+static int parse_long_options(char *const *nargv, const char *options,
+                              const struct option *long_options, int *idx,
+                              int short_too) {
+  char *current_argv, *has_equal;
+  size_t current_argv_len;
+  int i, match;
+
+  current_argv = const_cast<char *>(place);
+  match = -1;
+
+  optind++;
+
+  if ((has_equal = strchr(current_argv, '=')) != NULL) {
+    /* argument found (--option=arg) */
+    current_argv_len = has_equal - current_argv;
+    has_equal++;
+  } else
+    current_argv_len = strlen(current_argv);
+
+  for (i = 0; long_options[i].name; i++) {
+    /* find matching long option */
+    if (strncmp(current_argv, long_options[i].name, current_argv_len))
+      continue;
+
+    if (strlen(long_options[i].name) == current_argv_len) {
+      /* exact match */
+      match = i;
+      break;
     }
-    else
-        current_argv_len = strlen(current_argv);
-
-    for (i = 0; long_options[i].name; i++) {
-        /* find matching long option */
-        if (strncmp(current_argv, long_options[i].name,
-            current_argv_len))
-            continue;
-
-        if (strlen(long_options[i].name) == current_argv_len) {
-            /* exact match */
-            match = i;
-            break;
-        }
+    /*
+    * If this is a known short option, don't allow
+    * a partial match of a single character.
+    */
+    if (short_too && current_argv_len == 1)
+      continue;
+
+    if (match == -1) /* partial match */
+      match = i;
+    else {
+      /* ambiguous abbreviation */
+      if (PRINT_ERROR)
+        warnx(ambig, (int)current_argv_len, current_argv);
+      optopt = 0;
+      return (BADCH);
+    }
+  }
+  if (match != -1) { /* option found */
+    if (long_options[match].has_arg == no_argument && has_equal) {
+      if (PRINT_ERROR)
+        warnx(noarg, (int)current_argv_len, current_argv);
+      /*
+      * XXX: GNU sets optopt to val regardless of flag
+      */
+      if (long_options[match].flag == NULL)
+        optopt = long_options[match].val;
+      else
+        optopt = 0;
+      return (BADARG);
+    }
+    if (long_options[match].has_arg == required_argument ||
+        long_options[match].has_arg == optional_argument) {
+      if (has_equal)
+        optarg = has_equal;
+      else if (long_options[match].has_arg == required_argument) {
         /*
-        * If this is a known short option, don't allow
-        * a partial match of a single character.
+        * optional argument doesn't use next nargv
         */
-        if (short_too && current_argv_len == 1)
-            continue;
-
-        if (match == -1)    /* partial match */
-            match = i;
-        else {
-            /* ambiguous abbreviation */
-            if (PRINT_ERROR)
-                warnx(ambig, (int)current_argv_len,
-                current_argv);
-            optopt = 0;
-            return (BADCH);
-        }
+        optarg = nargv[optind++];
+      }
     }
-    if (match != -1) {      /* option found */
-        if (long_options[match].has_arg == no_argument
-            && has_equal) {
-            if (PRINT_ERROR)
-                warnx(noarg, (int)current_argv_len,
-                current_argv);
-            /*
-            * XXX: GNU sets optopt to val regardless of flag
-            */
-            if (long_options[match].flag == NULL)
-                optopt = long_options[match].val;
-            else
-                optopt = 0;
-            return (BADARG);
-        }
-        if (long_options[match].has_arg == required_argument ||
-            long_options[match].has_arg == optional_argument) {
-            if (has_equal)
-                optarg = has_equal;
-            else if (long_options[match].has_arg ==
-                required_argument) {
-                /*
-                * optional argument doesn't use next nargv
-                */
-                optarg = nargv[optind++];
-            }
-        }
-        if ((long_options[match].has_arg == required_argument)
-            && (optarg == NULL)) {
-            /*
-            * Missing argument; leading ':' indicates no error
-            * should be generated.
-            */
-            if (PRINT_ERROR)
-                warnx(recargstring,
-                current_argv);
-            /*
-            * XXX: GNU sets optopt to val regardless of flag
-            */
-            if (long_options[match].flag == NULL)
-                optopt = long_options[match].val;
-            else
-                optopt = 0;
-            --optind;
-            return (BADARG);
-        }
-    }
-    else {            /* unknown option */
-        if (short_too) {
-            --optind;
-            return (-1);
-        }
-        if (PRINT_ERROR)
-            warnx(illoptstring, current_argv);
+    if ((long_options[match].has_arg == required_argument) &&
+        (optarg == NULL)) {
+      /*
+      * Missing argument; leading ':' indicates no error
+      * should be generated.
+      */
+      if (PRINT_ERROR)
+        warnx(recargstring, current_argv);
+      /*
+      * XXX: GNU sets optopt to val regardless of flag
+      */
+      if (long_options[match].flag == NULL)
+        optopt = long_options[match].val;
+      else
         optopt = 0;
-        return (BADCH);
+      --optind;
+      return (BADARG);
     }
-    if (idx)
-        *idx = match;
-    if (long_options[match].flag) {
-        *long_options[match].flag = long_options[match].val;
-        return (0);
+  } else { /* unknown option */
+    if (short_too) {
+      --optind;
+      return (-1);
     }
-    else
-        return (long_options[match].val);
+    if (PRINT_ERROR)
+      warnx(illoptstring, current_argv);
+    optopt = 0;
+    return (BADCH);
+  }
+  if (idx)
+    *idx = match;
+  if (long_options[match].flag) {
+    *long_options[match].flag = long_options[match].val;
+    return (0);
+  } else
+    return (long_options[match].val);
 }
 
 /*
 * getopt_internal --
 *  Parse argc/argv argument vector.  Called by user level routines.
 */
-static int
-getopt_internal(int nargc, char * const *nargv, const char *options,
-const struct option *long_options, int *idx, int flags)
-{
-    const char *oli;                /* option letter list index */
-    int optchar, short_too;
-    static int posixly_correct = -1;
-
-    if (options == NULL)
-        return (-1);
-
-    /*
-    * XXX Some GNU programs (like cvs) set optind to 0 instead of
-    * XXX using optreset.  Work around this braindamage.
-    */
-    if (optind == 0)
-        optind = optreset = 1;
-
-    /*
-    * Disable GNU extensions if POSIXLY_CORRECT is set or options
-    * string begins with a '+'.
-    */
-    if (posixly_correct == -1 || optreset)
-        posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
-    if (*options == '-')
-        flags |= FLAG_ALLARGS;
-    else if (posixly_correct || *options == '+')
-        flags &= ~FLAG_PERMUTE;
-    if (*options == '+' || *options == '-')
-        options++;
-
-    optarg = NULL;
-    if (optreset)
-        nonopt_start = nonopt_end = -1;
+static int getopt_internal(int nargc, char *const *nargv, const char *options,
+                           const struct option *long_options, int *idx,
+                           int flags) {
+  const char *oli; /* option letter list index */
+  int optchar, short_too;
+  static int posixly_correct = -1;
+
+  if (options == NULL)
+    return (-1);
+
+  /*
+  * XXX Some GNU programs (like cvs) set optind to 0 instead of
+  * XXX using optreset.  Work around this braindamage.
+  */
+  if (optind == 0)
+    optind = optreset = 1;
+
+  /*
+  * Disable GNU extensions if POSIXLY_CORRECT is set or options
+  * string begins with a '+'.
+  */
+  if (posixly_correct == -1 || optreset)
+    posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
+  if (*options == '-')
+    flags |= FLAG_ALLARGS;
+  else if (posixly_correct || *options == '+')
+    flags &= ~FLAG_PERMUTE;
+  if (*options == '+' || *options == '-')
+    options++;
+
+  optarg = NULL;
+  if (optreset)
+    nonopt_start = nonopt_end = -1;
 start:
-    if (optreset || !*place) {      /* update scanning pointer */
-        optreset = 0;
-        if (optind >= nargc) {          /* end of argument vector */
-            place = EMSG;
-            if (nonopt_end != -1) {
-                /* do permutation, if we have to */
-                permute_args(nonopt_start, nonopt_end,
-                    optind, nargv);
-                optind -= nonopt_end - nonopt_start;
-            }
-            else if (nonopt_start != -1) {
-                /*
-                * If we skipped non-options, set optind
-                * to the first of them.
-                */
-                optind = nonopt_start;
-            }
-            nonopt_start = nonopt_end = -1;
-            return (-1);
-        }
-        if (*(place = nargv[optind]) != '-' ||
-            (place[1] == '\0' && strchr(options, '-') == NULL)) {
-            place = EMSG;       /* found non-option */
-            if (flags & FLAG_ALLARGS) {
-                /*
-                * GNU extension:
-                * return non-option as argument to option 1
-                */
-                optarg = nargv[optind++];
-                return (INORDER);
-            }
-            if (!(flags & FLAG_PERMUTE)) {
-                /*
-                * If no permutation wanted, stop parsing
-                * at first non-option.
-                */
-                return (-1);
-            }
-            /* do permutation */
-            if (nonopt_start == -1)
-                nonopt_start = optind;
-            else if (nonopt_end != -1) {
-                permute_args(nonopt_start, nonopt_end,
-                    optind, nargv);
-                nonopt_start = optind -
-                    (nonopt_end - nonopt_start);
-                nonopt_end = -1;
-            }
-            optind++;
-            /* process next argument */
-            goto start;
-        }
-        if (nonopt_start != -1 && nonopt_end == -1)
-            nonopt_end = optind;
-
+  if (optreset || !*place) { /* update scanning pointer */
+    optreset = 0;
+    if (optind >= nargc) { /* end of argument vector */
+      place = EMSG;
+      if (nonopt_end != -1) {
+        /* do permutation, if we have to */
+        permute_args(nonopt_start, nonopt_end, optind, nargv);
+        optind -= nonopt_end - nonopt_start;
+      } else if (nonopt_start != -1) {
+        /*
+        * If we skipped non-options, set optind
+        * to the first of them.
+        */
+        optind = nonopt_start;
+      }
+      nonopt_start = nonopt_end = -1;
+      return (-1);
+    }
+    if (*(place = nargv[optind]) != '-' ||
+        (place[1] == '\0' && strchr(options, '-') == NULL)) {
+      place = EMSG; /* found non-option */
+      if (flags & FLAG_ALLARGS) {
+        /*
+        * GNU extension:
+        * return non-option as argument to option 1
+        */
+        optarg = nargv[optind++];
+        return (INORDER);
+      }
+      if (!(flags & FLAG_PERMUTE)) {
         /*
-        * If we have "-" do nothing, if "--" we are done.
+        * If no permutation wanted, stop parsing
+        * at first non-option.
         */
-        if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
-            optind++;
-            place = EMSG;
-            /*
-            * We found an option (--), so if we skipped
-            * non-options, we have to permute.
-            */
-            if (nonopt_end != -1) {
-                permute_args(nonopt_start, nonopt_end,
-                    optind, nargv);
-                optind -= nonopt_end - nonopt_start;
-            }
-            nonopt_start = nonopt_end = -1;
-            return (-1);
-        }
+        return (-1);
+      }
+      /* do permutation */
+      if (nonopt_start == -1)
+        nonopt_start = optind;
+      else if (nonopt_end != -1) {
+        permute_args(nonopt_start, nonopt_end, optind, nargv);
+        nonopt_start = optind - (nonopt_end - nonopt_start);
+        nonopt_end = -1;
+      }
+      optind++;
+      /* process next argument */
+      goto start;
     }
+    if (nonopt_start != -1 && nonopt_end == -1)
+      nonopt_end = optind;
 
     /*
-    * Check long options if:
-    *  1) we were passed some
-    *  2) the arg is not just "-"
-    *  3) either the arg starts with -- we are getopt_long_only()
+    * If we have "-" do nothing, if "--" we are done.
     */
-    if (long_options != NULL && place != nargv[optind] &&
-        (*place == '-' || (flags & FLAG_LONGONLY))) {
-        short_too = 0;
-        if (*place == '-')
-            place++;        /* --foo long option */
-        else if (*place != ':' && strchr(options, *place) != NULL)
-            short_too = 1;      /* could be short option too */
-
-        optchar = parse_long_options(nargv, options, long_options,
-            idx, short_too);
-        if (optchar != -1) {
-            place = EMSG;
-            return (optchar);
-        }
+    if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
+      optind++;
+      place = EMSG;
+      /*
+      * We found an option (--), so if we skipped
+      * non-options, we have to permute.
+      */
+      if (nonopt_end != -1) {
+        permute_args(nonopt_start, nonopt_end, optind, nargv);
+        optind -= nonopt_end - nonopt_start;
+      }
+      nonopt_start = nonopt_end = -1;
+      return (-1);
+    }
+  }
+
+  /*
+  * Check long options if:
+  *  1) we were passed some
+  *  2) the arg is not just "-"
+  *  3) either the arg starts with -- we are getopt_long_only()
+  */
+  if (long_options != NULL && place != nargv[optind] &&
+      (*place == '-' || (flags & FLAG_LONGONLY))) {
+    short_too = 0;
+    if (*place == '-')
+      place++; /* --foo long option */
+    else if (*place != ':' && strchr(options, *place) != NULL)
+      short_too = 1; /* could be short option too */
+
+    optchar = parse_long_options(nargv, options, long_options, idx, short_too);
+    if (optchar != -1) {
+      place = EMSG;
+      return (optchar);
     }
+  }
 
-    if ((optchar = (int)*place++) == (int)':' ||
-        (optchar == (int)'-' && *place != '\0') ||
-        (oli = strchr(options, optchar)) == NULL) {
-        /*
-        * If the user specified "-" and  '-' isn't listed in
-        * options, return -1 (non-option) as per POSIX.
-        * Otherwise, it is an unknown option character (or ':').
-        */
-        if (optchar == (int)'-' && *place == '\0')
-            return (-1);
-        if (!*place)
-            ++optind;
+  if ((optchar = (int)*place++) == (int)':' ||
+      (optchar == (int)'-' && *place != '\0') ||
+      (oli = strchr(options, optchar)) == NULL) {
+    /*
+    * If the user specified "-" and  '-' isn't listed in
+    * options, return -1 (non-option) as per POSIX.
+    * Otherwise, it is an unknown option character (or ':').
+    */
+    if (optchar == (int)'-' && *place == '\0')
+      return (-1);
+    if (!*place)
+      ++optind;
+    if (PRINT_ERROR)
+      warnx(illoptchar, optchar);
+    optopt = optchar;
+    return (BADCH);
+  }
+  if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
+    /* -W long-option */
+    if (*place) /* no space */
+      /* NOTHING */;
+    else if (++optind >= nargc) { /* no arg */
+      place = EMSG;
+      if (PRINT_ERROR)
+        warnx(recargchar, optchar);
+      optopt = optchar;
+      return (BADARG);
+    } else /* white space */
+      place = nargv[optind];
+    optchar = parse_long_options(nargv, options, long_options, idx, 0);
+    place = EMSG;
+    return (optchar);
+  }
+  if (*++oli != ':') { /* doesn't take argument */
+    if (!*place)
+      ++optind;
+  } else { /* takes (optional) argument */
+    optarg = NULL;
+    if (*place) /* no white space */
+      optarg = const_cast<char *>(place);
+    else if (oli[1] != ':') {  /* arg not optional */
+      if (++optind >= nargc) { /* no arg */
+        place = EMSG;
         if (PRINT_ERROR)
-            warnx(illoptchar, optchar);
+          warnx(recargchar, optchar);
         optopt = optchar;
-        return (BADCH);
-    }
-    if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
-        /* -W long-option */
-        if (*place)         /* no space */
-            /* NOTHING */;
-        else if (++optind >= nargc) {   /* no arg */
-            place = EMSG;
-            if (PRINT_ERROR)
-                warnx(recargchar, optchar);
-            optopt = optchar;
-            return (BADARG);
-        }
-        else              /* white space */
-            place = nargv[optind];
-        optchar = parse_long_options(nargv, options, long_options,
-            idx, 0);
-        place = EMSG;
-        return (optchar);
-    }
-    if (*++oli != ':') {            /* doesn't take argument */
-        if (!*place)
-            ++optind;
+        return (BADARG);
+      } else
+        optarg = nargv[optind];
     }
-    else {                /* takes (optional) argument */
-        optarg = NULL;
-        if (*place)         /* no white space */
-            optarg = const_cast<char*>(place);
-        else if (oli[1] != ':') {   /* arg not optional */
-            if (++optind >= nargc) {    /* no arg */
-                place = EMSG;
-                if (PRINT_ERROR)
-                    warnx(recargchar, optchar);
-                optopt = optchar;
-                return (BADARG);
-            }
-            else
-                optarg = nargv[optind];
-        }
-        place = EMSG;
-        ++optind;
-    }
-    /* dump back option letter */
-    return (optchar);
+    place = EMSG;
+    ++optind;
+  }
+  /* dump back option letter */
+  return (optchar);
 }
 
 /*
@@ -425,19 +401,17 @@ start:
 * [eventually this will replace the BSD getopt]
 */
 #if defined(REPLACE_GETOPT)
-int
-getopt(int nargc, char * const *nargv, const char *options)
-{
-
-    /*
-    * We don't pass FLAG_PERMUTE to getopt_internal() since
-    * the BSD getopt(3) (unlike GNU) has never done this.
-    *
-    * Furthermore, since many privileged programs call getopt()
-    * before dropping privileges it makes sense to keep things
-    * as simple (and bug-free) as possible.
-    */
-    return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
+int getopt(int nargc, char *const *nargv, const char *options) {
+
+  /*
+  * We don't pass FLAG_PERMUTE to getopt_internal() since
+  * the BSD getopt(3) (unlike GNU) has never done this.
+  *
+  * Furthermore, since many privileged programs call getopt()
+  * before dropping privileges it makes sense to keep things
+  * as simple (and bug-free) as possible.
+  */
+  return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
 }
 #endif
 
@@ -446,12 +420,10 @@ getopt(int nargc, char * const *nargv, const char *options)
 *  Parse argc/argv argument vector.
 */
 #if defined(REPLACE_GETOPT_LONG)
-int
-getopt_long(int nargc, char * const *nargv, const char *options,
-const struct option *long_options, int *idx)
-{
-    return (getopt_internal(nargc, nargv, options, long_options, idx,
-        FLAG_PERMUTE));
+int getopt_long(int nargc, char *const *nargv, const char *options,
+                const struct option *long_options, int *idx) {
+  return (
+      getopt_internal(nargc, nargv, options, long_options, idx, FLAG_PERMUTE));
 }
 #endif
 
@@ -460,13 +432,11 @@ const struct option *long_options, int *idx)
 *  Parse argc/argv argument vector.
 */
 #if defined(REPLACE_GETOPT_LONG_ONLY)
-int
-getopt_long_only(int nargc, char * const *nargv, const char *options,
-const struct option *long_options, int *idx)
-{
+int getopt_long_only(int nargc, char *const *nargv, const char *options,
+                     const struct option *long_options, int *idx) {
 
-    return (getopt_internal(nargc, nargv, options, long_options, idx,
-        FLAG_PERMUTE | FLAG_LONGONLY));
+  return (getopt_internal(nargc, nargv, options, long_options, idx,
+                          FLAG_PERMUTE | FLAG_LONGONLY));
 }
 #endif