GETOPT(3)         Cosmopolitan Library Functions Manual              GETOPT(3)

ðððð
     ð´ð²ðð¼ð½ð â get option character from command line argument list

ðððððððð
     #ð¶ð»ð°ð¹ðð±ð² <ðð»ð¶ððð±.ðµ>

     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² cÌ²hÌ²aÌ²rÌ² *Ì²oÌ²pÌ²tÌ²aÌ²rÌ²gÌ²;Ì²
     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² iÌ²nÌ²tÌ² oÌ²pÌ²tÌ²eÌ²rÌ²rÌ²;Ì²
     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² iÌ²nÌ²tÌ² oÌ²pÌ²tÌ²iÌ²nÌ²dÌ²;Ì²
     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² iÌ²nÌ²tÌ² oÌ²pÌ²tÌ²oÌ²pÌ²tÌ²;Ì²
     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² iÌ²nÌ²tÌ² oÌ²pÌ²tÌ²rÌ²eÌ²sÌ²eÌ²tÌ²;Ì²

     iÌ²nÌ²tÌ²
     ð´ð²ðð¼ð½ð(iÌ²nÌ²tÌ² aÌ²rÌ²gÌ²cÌ², cÌ²hÌ²aÌ²rÌ² *Ì² cÌ²oÌ²nÌ²sÌ²tÌ² *Ì²aÌ²rÌ²gÌ²vÌ², cÌ²oÌ²nÌ²sÌ²tÌ² cÌ²hÌ²aÌ²rÌ² *Ì²oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ²);

ððððððððððð
     The ð´ð²ðð¼ð½ð() function incrementally parses a command line argument
     list aÌ²rÌ²gÌ²vÌ² and returns the next kÌ²nÌ²oÌ²wÌ²nÌ² option character.  An option
     character is kÌ²nÌ²oÌ²wÌ²nÌ² if it has been specified in the string of
     accepted option characters, oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ².

     The option string oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ² may contain the following elements:
     individual characters, characters followed by a colon, and characâ
     ters followed by two colons.  A character followed by a single
     colon indicates that an argument is to follow the option on the
     command line.  Two colons indicates that the argument is optional -
     this is an extension not covered by POSIX.  For example, an option
     string "x" recognizes an option -ð, and an option string "x:" recâ
     ognizes an option and argument -ð aÌ²rÌ²gÌ²uÌ²mÌ²eÌ²nÌ²tÌ².  It does not matter to
     ð´ð²ðð¼ð½ð() if a following argument has leading whitespace; except in
     the case where the argument is optional, denoted with two colons,
     no leading whitespace is permitted.

     On return from ð´ð²ðð¼ð½ð(), oÌ²pÌ²tÌ²aÌ²rÌ²gÌ² points to an option argument, if it
     is anticipated, and the variable oÌ²pÌ²tÌ²iÌ²nÌ²dÌ² contains the index to the
     next aÌ²rÌ²gÌ²vÌ² argument for a subsequent call to ð´ð²ðð¼ð½ð().

     The variables oÌ²pÌ²tÌ²eÌ²rÌ²rÌ² and oÌ²pÌ²tÌ²iÌ²nÌ²dÌ² are both initialized to 1.  The
     oÌ²pÌ²tÌ²iÌ²nÌ²dÌ² variable may be set to another value larger than 0 before a
     set of calls to ð´ð²ðð¼ð½ð() in order to skip over more or less aÌ²rÌ²gÌ²vÌ²
     entries.  An oÌ²pÌ²tÌ²iÌ²nÌ²dÌ² value of 0 is reserved for compatibility with
     GNU ð´ð²ðð¼ð½ð().

     In order to use ð´ð²ðð¼ð½ð() to evaluate multiple sets of arguments, or
     to evaluate a single set of arguments multiple times, the variable
     oÌ²pÌ²tÌ²rÌ²eÌ²sÌ²eÌ²tÌ² must be set to 1 before the second and each additional set
     of calls to ð´ð²ðð¼ð½ð(), and the variable oÌ²pÌ²tÌ²iÌ²nÌ²dÌ² must be reinitialâ
     ized.

     The ð´ð²ðð¼ð½ð() function returns -1 when the argument list is
     exhausted.  The interpretation of options in the argument list may
     be cancelled by the option â--â (double dash) which causes ð´ð²ðð¼ð½ð()
     to signal the end of argument processing and return -1.  When all
     options have been processed (i.e., up to the first non-option arguâ
     ment), ð´ð²ðð¼ð½ð() returns -1.

ðððððð ðððððð
     The ð´ð²ðð¼ð½ð() function returns the next known option character in
     oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ².  If ð´ð²ðð¼ð½ð() encounters a character not found in
     oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ² or if it detects a missing option argument, it returns
     â?â (question mark).  If oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ² has a leading â:â then a missing
     option argument causes â:â to be returned instead of â?â.  In
     either case, the variable oÌ²pÌ²tÌ²oÌ²pÌ²tÌ² is set to the character that
     caused the error.  The ð´ð²ðð¼ð½ð() function returns -1 when the arguâ
     ment list is exhausted.

ðððððððð
     The following code accepts the options -ð¯ and -ð³ aÌ²rÌ²gÌ²uÌ²mÌ²eÌ²nÌ²tÌ² and
     adjusts aÌ²rÌ²gÌ²cÌ² and aÌ²rÌ²gÌ²vÌ² after option argument processing has comâ
     pleted.

           int bflag, ch, fd;

           bflag = 0;
           while ((ch = getopt(argc, argv, "bf:")) != -1) {
                   switch (ch) {
                   case 'b':
                           bflag = 1;
                           break;
                   case 'f':
                           if ((fd = open(optarg, O_RDONLY, 0)) == -1)
                                   err(1, "%s", optarg);
                           break;
                   default:
                           usage();
                   }
           }
           argc -= optind;
           argv += optind;

ððððððððððð
     If the ð´ð²ðð¼ð½ð() function encounters a character not found in the
     string oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ² or detects a missing option argument, it writes an
     error message to sÌ²tÌ²dÌ²eÌ²rÌ²rÌ² and returns â?â.  Setting oÌ²pÌ²tÌ²eÌ²rÌ²rÌ² to a zero
     will disable these error messages.  If oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ² has a leading â:â
     then a missing option argument causes a â:â to be returned in addiâ
     tion to suppressing any error messages.

     Option arguments are allowed to begin with â-â; this is reasonable
     but reduces the amount of error checking possible.

ððð ðððð
     getopt(1), getopt_long(3), getsubopt(3)

ððððððððð
     The ð´ð²ðð¼ð½ð() function implements a superset of the functionality
     specified by IEEE Std 1003.1 (âPOSIX.1â).

     The following extensions are supported:

     Â·   The oÌ²pÌ²tÌ²rÌ²eÌ²sÌ²eÌ²tÌ² variable was added to make it possible to call the
         ð´ð²ðð¼ð½ð() function multiple times.

     Â·   If the oÌ²pÌ²tÌ²iÌ²nÌ²dÌ² variable is set to 0, ð´ð²ðð¼ð½ð() will behave as if
         the oÌ²pÌ²tÌ²rÌ²eÌ²sÌ²eÌ²tÌ² variable has been set.  This is for compatibility
         with GNU ð´ð²ðð¼ð½ð().  New code should use oÌ²pÌ²tÌ²rÌ²eÌ²sÌ²eÌ²tÌ² instead.

     Â·   If the first character of oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ² is a plus sign (â+â), it
         will be ignored.  This is for compatibility with GNU ð´ð²ðð¼ð½ð().

     Â·   If the first character of oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ² is a dash (â-â), non-
         options will be returned as arguments to the option character
         â\1â.  This is for compatibility with GNU ð´ð²ðð¼ð½ð().

     Â·   A single dash (â-â) may be specified as a character in
         oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ², however it should nÌ²eÌ²vÌ²eÌ²rÌ² have an argument associated
         with it.  This allows ð´ð²ðð¼ð½ð() to be used with programs that
         expect â-â as an option flag.  This practice is wrong, and
         should not be used in any current development.  It is provided
         for backward compatibility oÌ²nÌ²lÌ²yÌ².  Care should be taken not to
         use â-â as the first character in oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ² to avoid a semantic
         conflict with GNU ð´ð²ðð¼ð½ð() semantics (see above).  By default,
         a single dash causes ð´ð²ðð¼ð½ð() to return -1.

     Historic BSD versions of ð´ð²ðð¼ð½ð() set oÌ²pÌ²tÌ²oÌ²pÌ²tÌ² to the last option
     character processed.  However, this conflicts with IEEE Std 1003.1
     (âPOSIX.1â) which stipulates that oÌ²pÌ²tÌ²oÌ²pÌ²tÌ² be set to the last characâ
     ter that caused an error.

ððððððð
     The ð´ð²ðð¼ð½ð() function appeared in 4.3BSD.

ðððð
     The ð´ð²ðð¼ð½ð() function was once specified to return EOF instead of
     -1.  This was changed by IEEE Std 1003.2-1992 (âPOSIX.2â) to decouâ
     ple ð´ð²ðð¼ð½ð() from <sÌ²tÌ²dÌ²iÌ²oÌ².Ì²hÌ²>.

     It is possible to handle digits as option letters.  This allows
     ð´ð²ðð¼ð½ð() to be used with programs that expect a number (â-3â) as an
     option.  This practice is wrong, and should not be used in any curâ
     rent development.  It is provided for backward compatibility oÌ²nÌ²lÌ²yÌ².
     The following code fragment works in most cases and can handle
     mixed number and letter arguments.

           int aflag = 0, bflag = 0, ch, lastch = '\0';
           int length = -1, newarg = 1, prevoptind = 1;

           while ((ch = getopt(argc, argv, "0123456789ab")) != -1) {
                   switch (ch) {
                   case '0': case '1': case '2': case '3': case '4':
                   case '5': case '6': case '7': case '8': case '9':
                           if (newarg || !isdigit(lastch))
                                   length = 0;
                           else if (length > INT_MAX / 10)
                                   usage();
                           length = (length * 10) + (ch - '0');
                           break;
                   case 'a':
                           aflag = 1;
                           break;
                   case 'b':
                           bflag = 1;
                           break;
                   default:
                           usage();
                   }
                   lastch = ch;
                   newarg = optind != prevoptind;
                   prevoptind = optind;
           }

COSMOPOLITAN                    January 4, 2016                            BSD

ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ

GETOPT_LONG(3)      Cosmopolitan Library Functions Manual       GETOPT_LONG(3)

ðððð
     ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´, ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´_ð¼ð»ð¹ð â get long options from command line
     argument list

ðððððððð
     #ð¶ð»ð°ð¹ðð±ð² <ð´ð²ðð¼ð½ð.ðµ>

     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² cÌ²hÌ²aÌ²rÌ² *Ì²oÌ²pÌ²tÌ²aÌ²rÌ²gÌ²;Ì²
     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² iÌ²nÌ²tÌ² oÌ²pÌ²tÌ²iÌ²nÌ²dÌ²;Ì²
     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² iÌ²nÌ²tÌ² oÌ²pÌ²tÌ²oÌ²pÌ²tÌ²;Ì²
     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² iÌ²nÌ²tÌ² oÌ²pÌ²tÌ²eÌ²rÌ²rÌ²;Ì²
     eÌ²xÌ²tÌ²eÌ²rÌ²nÌ² iÌ²nÌ²tÌ² oÌ²pÌ²tÌ²rÌ²eÌ²sÌ²eÌ²tÌ²;Ì²

     iÌ²nÌ²tÌ²
     ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´(iÌ²nÌ²tÌ² aÌ²rÌ²gÌ²cÌ², cÌ²hÌ²aÌ²rÌ² *Ì² cÌ²oÌ²nÌ²sÌ²tÌ² *Ì²aÌ²rÌ²gÌ²vÌ², cÌ²oÌ²nÌ²sÌ²tÌ² cÌ²hÌ²aÌ²rÌ² *Ì²oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ²,
         cÌ²oÌ²nÌ²sÌ²tÌ² sÌ²tÌ²rÌ²uÌ²cÌ²tÌ² oÌ²pÌ²tÌ²iÌ²oÌ²nÌ² *Ì²lÌ²oÌ²nÌ²gÌ²oÌ²pÌ²tÌ²sÌ², iÌ²nÌ²tÌ² *Ì²lÌ²oÌ²nÌ²gÌ²iÌ²nÌ²dÌ²eÌ²xÌ²);

     iÌ²nÌ²tÌ²
     ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´_ð¼ð»ð¹ð(iÌ²nÌ²tÌ² aÌ²rÌ²gÌ²cÌ², cÌ²hÌ²aÌ²rÌ² *Ì² cÌ²oÌ²nÌ²sÌ²tÌ² *Ì²aÌ²rÌ²gÌ²vÌ²,
         cÌ²oÌ²nÌ²sÌ²tÌ² cÌ²hÌ²aÌ²rÌ² *Ì²oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ², cÌ²oÌ²nÌ²sÌ²tÌ² sÌ²tÌ²rÌ²uÌ²cÌ²tÌ² oÌ²pÌ²tÌ²iÌ²oÌ²nÌ² *Ì²lÌ²oÌ²nÌ²gÌ²oÌ²pÌ²tÌ²sÌ²,
         iÌ²nÌ²tÌ² *Ì²lÌ²oÌ²nÌ²gÌ²iÌ²nÌ²dÌ²eÌ²xÌ²);

ððððððððððð
     The ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´() function is similar to getopt(3) but it accepts
     options in two forms: words and characters.  The ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´()
     function provides a superset of the functionality of getopt(3).
     ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´() can be used in two ways.  In the first way, every
     long option understood by the program has a corresponding short
     option, and the option structure is only used to translate from
     long options to short options.  When used in this fashion,
     ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´() behaves identically to getopt(3).  This is a good way
     to add long option processing to an existing program with the miniâ
     mum of rewriting.

     In the second mechanism, a long option sets a flag in the oÌ²pÌ²tÌ²iÌ²oÌ²nÌ²
     structure passed, or will store a pointer to the command line arguâ
     ment in the oÌ²pÌ²tÌ²iÌ²oÌ²nÌ² structure passed to it for options that take
     arguments.  Additionally, the long option's argument may be speciâ
     fied as a single argument with an equal sign, e.g.

           $ myprogram --myoption=somevalue

     When a long option is processed, the call to ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´() will
     return 0.  For this reason, long option processing without shortâ
     cuts is not backwards compatible with getopt(3).

     It is possible to combine these methods, providing for long options
     processing with short option equivalents for some options.  Less
     frequently used options would be processed as long options only.

     Abbreviated long option names are accepted when ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´() proâ
     cesses long options if the abbreviation is unique.  An exact match
     is always preferred for a defined long option.

     The ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´() call requires an array to be initialized describâ
     ing the long options.  Each element of the array is a structure:

           struct option {
                   char *name;
                   int has_arg;
                   int *flag;
                   int val;
           };

     The nÌ²aÌ²mÌ²eÌ² field should contain the option name without the leading
     double dash.

     The hÌ²aÌ²sÌ²_aÌ²rÌ²gÌ² field should be one of:

           no_argument        no argument to the option is expected.
           required_argument  an argument to the option is required.
           optional_argument  an argument to the option may be preâ
                              sented.

     If fÌ²lÌ²aÌ²gÌ² is not NULL, then the integer pointed to by it will be set
     to the value in the vÌ²aÌ²lÌ² field.  If the fÌ²lÌ²aÌ²gÌ² field is NULL, then the
     vÌ²aÌ²lÌ² field will be returned.  Setting fÌ²lÌ²aÌ²gÌ² to NULL and setting vÌ²aÌ²lÌ²
     to the corresponding short option will make this function act just
     like getopt(3).

     If the lÌ²oÌ²nÌ²gÌ²iÌ²nÌ²dÌ²eÌ²xÌ² field is not NULL, then the integer pointed to by
     it will be set to the index of the long option relative to
     lÌ²oÌ²nÌ²gÌ²oÌ²pÌ²tÌ²sÌ².

     The last element of the lÌ²oÌ²nÌ²gÌ²oÌ²pÌ²tÌ²sÌ² array has to be filled with
     zeroes.

     The ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´_ð¼ð»ð¹ð() function behaves identically to
     ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´() with the exception that long options may start with
     â-â in addition to â--â.  If an option starting with â-â does not
     match a long option but does match a single-character option, the
     single-character option is returned.

ðððððð ðððððð
     If the fÌ²lÌ²aÌ²gÌ² field in struct option is NULL, ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´() and
     ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´_ð¼ð»ð¹ð() return the value specified in the vÌ²aÌ²lÌ² field,
     which is usually just the corresponding short option.  If fÌ²lÌ²aÌ²gÌ² is
     not NULL, these functions return 0 and store vÌ²aÌ²lÌ² in the location
     pointed to by fÌ²lÌ²aÌ²gÌ².  These functions return â:â if there was a
     missing option argument, â?â if the user specified an unknown or
     ambiguous option, and -1 when the argument list has been exhausted.

ðððððððððððððð ððððððððððð
     This section describes differences to the GNU implementation found
     in glibc-2.1.3:

     Â·   handling of â-â within the option string (not the first characâ
         ter):

         GNU      treats a â-â on the command line as a non-argument.

         OpenBSD  a â-â within the option string matches a â-â (single
                  dash) on the command line.  This functionality is proâ
                  vided for backward compatibility with programs, such
                  as su(1), that use â-â as an option flag.  This pracâ
                  tice is wrong, and should not be used in any current
                  development.

     Â·   handling of â::â in the option string in the presence of
         POSIXLY_CORRECT:

         Both     GNU and OpenBSD ignore POSIXLY_CORRECT here and take
                  â::â to mean the preceding option takes an optional
                  argument.

     Â·   return value in case of missing argument if first character
         (after â+â or â-â) in the option string is not â:â:

         GNU      returns â?â

         OpenBSD  returns â:â (since OpenBSD's getopt(3) does).

     Â·   handling of â--aâ in getopt(3):

         GNU      parses this as option â-â, option âaâ.

         OpenBSD  parses this as â--â, and returns -1 (ignoring the âaâ)
                  (because the original ð´ð²ðð¼ð½ð() did.)

     Â·   setting of oÌ²pÌ²tÌ²oÌ²pÌ²tÌ² for long options with fÌ²lÌ²aÌ²gÌ² non-NULL:

         GNU      sets oÌ²pÌ²tÌ²oÌ²pÌ²tÌ² to vÌ²aÌ²lÌ².

         OpenBSD  sets oÌ²pÌ²tÌ²oÌ²pÌ²tÌ² to 0 (since vÌ²aÌ²lÌ² would never be returned).

     Â·   handling of â-Wâ with âW;â in the option string in getopt(3)
         (not ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´()):

         GNU      causes a segmentation fault.

         OpenBSD  no special handling is done; âW;â is interpreted as
                  two separate options, neither of which take an arguâ
                  ment.

     Â·   setting of oÌ²pÌ²tÌ²aÌ²rÌ²gÌ² for long options without an argument that are
         invoked via â-Wâ (with âW;â in the option string):

         GNU      sets oÌ²pÌ²tÌ²aÌ²rÌ²gÌ² to the option name (the argument of â-Wâ).

         OpenBSD  sets oÌ²pÌ²tÌ²aÌ²rÌ²gÌ² to NULL (the argument of the long option).

     Â·   handling of â-Wâ with an argument that is not (a prefix to) a
         known long option (with âW;â in the option string):

         GNU      returns â-Wâ with oÌ²pÌ²tÌ²aÌ²rÌ²gÌ² set to the unknown option.

         OpenBSD  treats this as an error (unknown option) and returns
                  â?â with oÌ²pÌ²tÌ²oÌ²pÌ²tÌ² set to 0 and oÌ²pÌ²tÌ²aÌ²rÌ²gÌ² set to NULL (as
                  GNU's man page documents).

     Â·   The error messages are different.

     Â·   OpenBSD does not permute the argument vector at the same points
         in the calling sequence as GNU does.  The aspects normally used
         by the caller (ordering after -1 is returned, value of oÌ²pÌ²tÌ²iÌ²nÌ²dÌ²
         relative to current positions) are the same, though.  (We do
         fewer variable swaps.)

ððððððððððð
     POSIXLY_CORRECT  If set, option processing stops when the first
                      non-option is found and a leading â+â in the
                      oÌ²pÌ²tÌ²sÌ²tÌ²rÌ²iÌ²nÌ²gÌ² is ignored.

ðððððððð
     int bflag, ch, fd;
     int daggerset;

     /* options descriptor */
     static struct option longopts[] = {
             { "buffy",      no_argument,            NULL,           'b' },
             { "fluoride",   required_argument,      NULL,           'f' },
             { "daggerset",  no_argument,            &daggerset,     1 },
             { NULL,         0,                      NULL,           0 }
     };

     bflag = 0;
     while ((ch = getopt_long(argc, argv, "bf:", longopts, NULL)) != -1)
             switch (ch) {
             case 'b':
                     bflag = 1;
                     break;
             case 'f':
                     if ((fd = open(optarg, O_RDONLY, 0)) == -1)
                             err(1, "unable to open %s", optarg);
                     break;
             case 0:
                     if (daggerset)
                             fprintf(stderr, "Buffy will use her dagger to "
                                 "apply fluoride to dracula's teeth\n");
                     break;
             default:
                     usage();
             }
     argc -= optind;
     argv += optind;

ððð ðððð
     getopt(3)

ððððððð
     The ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´() and ð´ð²ðð¼ð½ð_ð¹ð¼ð»ð´_ð¼ð»ð¹ð() functions first appeared
     in GNU libiberty.  This implementation first appeared in
     OpenBSD 3.3.

ðððð
     The aÌ²rÌ²gÌ²vÌ² argument is not really const as its elements may be perâ
     muted (unless POSIXLY_CORRECT is set).

COSMOPOLITAN                    January 4, 2016                            BSD
