lib/argmatch.c

   1 /* argmatch.c -- find a match for a string in an array
   2
   3    Copyright (C) 1990, 1998-1999, 2001-2007, 2009-2024 Free Software
   4    Foundation, Inc.
   5
   6    This program is free software: you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation, either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  18
  19 /* Written by David MacKenzie <djm@ai.mit.edu>
  20    Modified by Akim Demaille <demaille@inf.enst.fr> */
  21
  22 #include <config.h>
  23
  24 /* Specification.  */
  25 #include "argmatch.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #define _(msgid) gettext (msgid)
  32
  33 #include <error.h>
  34 #include "quotearg.h"
  35
  36 #if USE_UNLOCKED_IO
  37 # include "unlocked-io.h"
  38 #endif
  39
  40 /* When reporting an invalid argument, show nonprinting characters
  41    by using the quoting style ARGMATCH_QUOTING_STYLE.  Do not use
  42    literal_quoting_style.  */
  43 #ifndef ARGMATCH_QUOTING_STYLE
  44 # define ARGMATCH_QUOTING_STYLE locale_quoting_style
  45 #endif
  46
  47 /* Non failing version of argmatch call this function after failing. */
  48 #ifndef ARGMATCH_DIE
  49 # include "exitfail.h"
  50 # define ARGMATCH_DIE exit (exit_failure)
  51 #endif
  52
  53 #ifdef ARGMATCH_DIE_DECL
  54 ARGMATCH_DIE_DECL;
  55 #endif
  56
  57 static void
  58 __argmatch_die (void)
  59 {
  60   ARGMATCH_DIE;
  61 }
  62
  63 /* Used by XARGMATCH.  See description in argmatch.h.
  64    Default to __argmatch_die, but allow caller to change this at run-time. */
  65 argmatch_exit_fn argmatch_die = __argmatch_die;
  66
  67 \f
  68 /* If ARG is an unambiguous match for an element of the
  69    NULL-terminated array ARGLIST, return the index in ARGLIST
  70    of the matched element, else -1 if it does not match any element
  71    or -2 if it is ambiguous (is a prefix of more than one element).
  72
  73    If VALLIST is none null, use it to resolve ambiguities limited to
  74    synonyms, i.e., for
  75      "yes", "yop" -> 0
  76      "no", "nope" -> 1
  77    "y" is a valid argument, for 0, and "n" for 1.  */
  78
  79 ptrdiff_t
  80 argmatch (const char *arg, const char *const *arglist,
  81           const void *vallist, size_t valsize)
  82 {
  83   size_t i;                     /* Temporary index in ARGLIST.  */
  84   size_t arglen;                /* Length of ARG.  */
  85   ptrdiff_t matchind = -1;      /* Index of first nonexact match.  */
  86   bool ambiguous = false;       /* If true, multiple nonexact match(es).  */
  87
  88   arglen = strlen (arg);
  89
  90   /* Test all elements for either exact match or abbreviated matches.  */
  91   for (i = 0; arglist[i]; i++)
  92     {
  93       if (!strncmp (arglist[i], arg, arglen))
  94         {
  95           if (strlen (arglist[i]) == arglen)
  96             /* Exact match found.  */
  97             return i;
  98           else if (matchind == -1)
  99             /* First nonexact match found.  */
 100             matchind = i;
 101           else
 102             {
 103               /* Second nonexact match found.  */
 104               if (vallist == NULL
 105                   || memcmp ((char const *) vallist + valsize * matchind,
 106                              (char const *) vallist + valsize * i, valsize))
 107                 {
 108                   /* There is a real ambiguity, or we could not
 109                      disambiguate. */
 110                   ambiguous = true;
 111                 }
 112             }
 113         }
 114     }
 115   if (ambiguous)
 116     return -2;
 117   else
 118     return matchind;
 119 }
 120
 121 ptrdiff_t
 122 argmatch_exact (const char *arg, const char *const *arglist)
 123 {
 124   size_t i;
 125
 126   /* Test elements for exact match.  */
 127   for (i = 0; arglist[i]; i++)
 128     {
 129       if (!strcmp (arglist[i], arg))
 130         return i;
 131     }
 132
 133   return -1;
 134 }
 135
 136 /* Error reporting for argmatch.
 137    CONTEXT is a description of the type of entity that was being matched.
 138    VALUE is the invalid value that was given.
 139    PROBLEM is the return value from argmatch.  */
 140
 141 void
 142 argmatch_invalid (const char *context, const char *value, ptrdiff_t problem)
 143 {
 144   char const *format = (problem == -1
 145                         ? _("invalid argument %s for %s")
 146                         : _("ambiguous argument %s for %s"));
 147
 148   error (0, 0, format, quotearg_n_style (0, ARGMATCH_QUOTING_STYLE, value),
 149          quote_n (1, context));
 150 }
 151
 152 /* List the valid arguments for argmatch.
 153    ARGLIST is the same as in argmatch.
 154    VALLIST is a pointer to an array of values.
 155    VALSIZE is the size of the elements of VALLIST */
 156 void
 157 argmatch_valid (const char *const *arglist,
 158                 const void *vallist, size_t valsize)
 159 {
 160   size_t i;
 161   const char *last_val = NULL;
 162
 163   /* We try to put synonyms on the same line.  The assumption is that
 164      synonyms follow each other */
 165   fputs (_("Valid arguments are:"), stderr);
 166   for (i = 0; arglist[i]; i++)
 167     if ((i == 0)
 168         || memcmp (last_val, (char const *) vallist + valsize * i, valsize))
 169       {
 170         fprintf (stderr, "\n  - %s", quote (arglist[i]));
 171         last_val = (char const *) vallist + valsize * i;
 172       }
 173     else
 174       {
 175         fprintf (stderr, ", %s", quote (arglist[i]));
 176       }
 177   putc ('\n', stderr);
 178 }
 179
 180 /* Never failing versions of the previous functions.
 181
 182    CONTEXT is the context for which argmatch is called (e.g.,
 183    "--version-control", or "$VERSION_CONTROL" etc.).  Upon failure,
 184    calls the (supposed never to return) function EXIT_FN. */
 185
 186 ptrdiff_t
 187 __xargmatch_internal (const char *context,
 188                       const char *arg, const char *const *arglist,
 189                       const void *vallist, size_t valsize,
 190                       argmatch_exit_fn exit_fn,
 191                       bool allow_abbreviation)
 192 {
 193   ptrdiff_t res;
 194
 195   if (allow_abbreviation)
 196     res = argmatch (arg, arglist, vallist, valsize);
 197   else
 198     res = argmatch_exact (arg, arglist);
 199
 200   if (res >= 0)
 201     /* Success. */
 202     return res;
 203
 204   /* We failed.  Explain why. */
 205   argmatch_invalid (context, arg, res);
 206   argmatch_valid (arglist, vallist, valsize);
 207   (*exit_fn) ();
 208
 209   return -1; /* To please the compilers. */
 210 }
 211
 212 /* Look for VALUE in VALLIST, an array of objects of size VALSIZE and
 213    return the first corresponding argument in ARGLIST */
 214 const char *
 215 argmatch_to_argument (const void *value,
 216                       const char *const *arglist,
 217                       const void *vallist, size_t valsize)
 218 {
 219   size_t i;
 220
 221   for (i = 0; arglist[i]; i++)
 222     if (!memcmp (value, (char const *) vallist + valsize * i, valsize))
 223       return arglist[i];
 224   return NULL;
 225 }
 226
 227 #ifdef TEST
 228 /*
 229  * Based on "getversion.c" by David MacKenzie <djm@gnu.ai.mit.edu>
 230  */
 231
 232 /* When to make backup files.  */
 233 enum backup_type
 234 {
 235   /* Never make backups.  */
 236   no_backups,
 237
 238   /* Make simple backups of every file.  */
 239   simple_backups,
 240
 241   /* Make numbered backups of files that already have numbered backups,
 242      and simple backups of the others.  */
 243   numbered_existing_backups,
 244
 245   /* Make numbered backups of every file.  */
 246   numbered_backups
 247 };
 248
 249 /* Two tables describing arguments (keys) and their corresponding
 250    values */
 251 static const char *const backup_args[] =
 252 {
 253   "no", "none", "off",
 254   "simple", "never",
 255   "existing", "nil",
 256   "numbered", "t",
 257   0
 258 };
 259
 260 static const enum backup_type backup_vals[] =
 261 {
 262   no_backups, no_backups, no_backups,
 263   simple_backups, simple_backups,
 264   numbered_existing_backups, numbered_existing_backups,
 265   numbered_backups, numbered_backups
 266 };
 267
 268 int
 269 main (int argc, const char *const *argv)
 270 {
 271   const char *cp;
 272   enum backup_type backup_type = no_backups;
 273
 274   if (argc > 2)
 275     {
 276       fprintf (stderr, "Usage: %s [VERSION_CONTROL]\n", getprogname ());
 277       exit (1);
 278     }
 279
 280   if ((cp = getenv ("VERSION_CONTROL")))
 281     backup_type = XARGMATCH ("$VERSION_CONTROL", cp,
 282                              backup_args, backup_vals);
 283
 284   if (argc == 2)
 285     backup_type = XARGMATCH (getprogname (), argv[1],
 286                              backup_args, backup_vals);
 287
 288   printf ("The version control is '%s'\n",
 289           ARGMATCH_TO_ARGUMENT (&backup_type, backup_args, backup_vals));
 290
 291   return 0;
 292 }
 293 #endif