contrib/bc/src/opt.c

   1 /*
   2  * *****************************************************************************
   3  *
   4  * SPDX-License-Identifier: BSD-2-Clause
   5  *
   6  * Copyright (c) 2018-2023 Gavin D. Howard and contributors.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * * Redistributions of source code must retain the above copyright notice, this
  12  *   list of conditions and the following disclaimer.
  13  *
  14  * * Redistributions in binary form must reproduce the above copyright notice,
  15  *   this list of conditions and the following disclaimer in the documentation
  16  *   and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * *****************************************************************************
  31  *
  32  * Adapted from https://github.com/skeeto/optparse
  33  *
  34  * *****************************************************************************
  35  *
  36  * Code for getopt_long() replacement. It turns out that getopt_long() has
  37  * different behavior on different platforms.
  38  *
  39  */
  40
  41 #include <assert.h>
  42 #include <stdbool.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45
  46 #include <status.h>
  47 #include <opt.h>
  48 #include <vm.h>
  49
  50 /**
  51  * Returns true if index @a i is the end of the longopts array.
  52  * @param longopts  The long options array.
  53  * @param i         The index to test.
  54  * @return          True if @a i is the last index, false otherwise.
  55  */
  56 static inline bool
  57 bc_opt_longoptsEnd(const BcOptLong* longopts, size_t i)
  58 {
  59         return !longopts[i].name && !longopts[i].val;
  60 }
  61
  62 /**
  63  * Returns the name of the long option that matches the character @a c.
  64  * @param longopts  The long options array.
  65  * @param c         The character to match against.
  66  * @return          The name of the long option that matches @a c, or "NULL".
  67  */
  68 static const char*
  69 bc_opt_longopt(const BcOptLong* longopts, int c)
  70 {
  71         size_t i;
  72
  73         for (i = 0; !bc_opt_longoptsEnd(longopts, i); ++i)
  74         {
  75                 if (longopts[i].val == c) return longopts[i].name;
  76         }
  77
  78         BC_UNREACHABLE
  79
  80 #if !BC_CLANG
  81         return "NULL";
  82 #endif // !BC_CLANG
  83 }
  84
  85 /**
  86  * Issues a fatal error for an option parsing failure.
  87  * @param err        The error.
  88  * @param c          The character for the failing option.
  89  * @param str        Either the string for the failing option, or the invalid
  90  *                   option.
  91  * @param use_short  True if the short option should be used for error printing,
  92  *                   false otherwise.
  93  */
  94 static void
  95 bc_opt_error(BcErr err, int c, const char* str, bool use_short)
  96 {
  97         if (err == BC_ERR_FATAL_OPTION)
  98         {
  99                 if (use_short)
 100                 {
 101                         char short_str[2];
 102
 103                         short_str[0] = (char) c;
 104                         short_str[1] = '\0';
 105
 106                         bc_error(err, 0, short_str);
 107                 }
 108                 else bc_error(err, 0, str);
 109         }
 110         else bc_error(err, 0, (int) c, str);
 111 }
 112
 113 /**
 114  * Returns the type of the long option that matches @a c.
 115  * @param longopts  The long options array.
 116  * @param c         The character to match against.
 117  * @return          The type of the long option as an integer, or -1 if none.
 118  */
 119 static int
 120 bc_opt_type(const BcOptLong* longopts, char c)
 121 {
 122         size_t i;
 123
 124         if (c == ':') return -1;
 125
 126         for (i = 0; !bc_opt_longoptsEnd(longopts, i) && longopts[i].val != c; ++i)
 127         {
 128                 continue;
 129         }
 130
 131         if (bc_opt_longoptsEnd(longopts, i)) return -1;
 132
 133         return (int) longopts[i].type;
 134 }
 135
 136 /**
 137  * Parses a short option.
 138  * @param o         The option parser.
 139  * @param longopts  The long options array.
 140  * @return          The character for the short option, or -1 if none left.
 141  */
 142 static int
 143 bc_opt_parseShort(BcOpt* o, const BcOptLong* longopts)
 144 {
 145         int type;
 146         char* next;
 147         char* option = o->argv[o->optind];
 148         int ret = -1;
 149
 150         // Make sure to clear these.
 151         o->optopt = 0;
 152         o->optarg = NULL;
 153
 154         // Get the next option.
 155         option += o->subopt + 1;
 156         o->optopt = option[0];
 157
 158         // Get the type and the next data.
 159         type = bc_opt_type(longopts, option[0]);
 160         next = o->argv[o->optind + 1];
 161
 162         switch (type)
 163         {
 164                 case -1:
 165                 case BC_OPT_BC_ONLY:
 166                 case BC_OPT_DC_ONLY:
 167                 {
 168                         // Check for invalid option and barf if so.
 169                         if (type == -1 || (type == BC_OPT_BC_ONLY && BC_IS_DC) ||
 170                             (type == BC_OPT_DC_ONLY && BC_IS_BC))
 171                         {
 172                                 char str[2] = { 0, 0 };
 173
 174                                 str[0] = option[0];
 175                                 o->optind += 1;
 176
 177                                 bc_opt_error(BC_ERR_FATAL_OPTION, option[0], str, true);
 178                         }
 179
 180                         // Fallthrough.
 181                         BC_FALLTHROUGH
 182                 }
 183
 184                 case BC_OPT_NONE:
 185                 {
 186                         // If there is something else, update the suboption.
 187                         if (option[1]) o->subopt += 1;
 188                         else
 189                         {
 190                                 // Go to the next argument.
 191                                 o->subopt = 0;
 192                                 o->optind += 1;
 193                         }
 194
 195                         ret = (int) option[0];
 196
 197                         break;
 198                 }
 199
 200                 case BC_OPT_REQUIRED_BC_ONLY:
 201                 {
 202 #if DC_ENABLED
 203                         if (BC_IS_DC)
 204                         {
 205                                 bc_opt_error(BC_ERR_FATAL_OPTION, option[0],
 206                                              bc_opt_longopt(longopts, option[0]), true);
 207                         }
 208 #endif // DC_ENABLED
 209
 210                         // Fallthrough
 211                         BC_FALLTHROUGH
 212                 }
 213
 214                 case BC_OPT_REQUIRED:
 215                 {
 216                         // Always go to the next argument.
 217                         o->subopt = 0;
 218                         o->optind += 1;
 219
 220                         // Use the next characters, if they exist.
 221                         if (option[1]) o->optarg = option + 1;
 222                         else if (next != NULL)
 223                         {
 224                                 // USe the next.
 225                                 o->optarg = next;
 226                                 o->optind += 1;
 227                         }
 228                         // No argument, barf.
 229                         else
 230                         {
 231                                 bc_opt_error(BC_ERR_FATAL_OPTION_NO_ARG, option[0],
 232                                              bc_opt_longopt(longopts, option[0]), true);
 233                         }
 234
 235                         ret = (int) option[0];
 236
 237                         break;
 238                 }
 239         }
 240
 241         return ret;
 242 }
 243
 244 /**
 245  * Ensures that a long option argument matches a long option name, regardless of
 246  * "=<data>" at the end.
 247  * @param name    The name to match.
 248  * @param option  The command-line argument.
 249  * @return        True if @a option matches @a name, false otherwise.
 250  */
 251 static bool
 252 bc_opt_longoptsMatch(const char* name, const char* option)
 253 {
 254         const char* a = option;
 255         const char* n = name;
 256
 257         // Can never match a NULL name.
 258         if (name == NULL) return false;
 259
 260         // Loop through.
 261         for (; *a && *n && *a != '='; ++a, ++n)
 262         {
 263                 if (*a != *n) return false;
 264         }
 265
 266         // Ensure they both end at the same place.
 267         return (*n == '\0' && (*a == '\0' || *a == '='));
 268 }
 269
 270 /**
 271  * Returns a pointer to the argument of a long option, or NULL if it not in the
 272  * same argument.
 273  * @param option  The option to find the argument of.
 274  * @return        A pointer to the argument of the option, or NULL if none.
 275  */
 276 static char*
 277 bc_opt_longoptsArg(char* option)
 278 {
 279         // Find the end or equals sign.
 280         for (; *option && *option != '='; ++option)
 281         {
 282                 continue;
 283         }
 284
 285         if (*option == '=') return option + 1;
 286         else return NULL;
 287 }
 288
 289 int
 290 bc_opt_parse(BcOpt* o, const BcOptLong* longopts)
 291 {
 292         size_t i;
 293         char* option;
 294         bool empty;
 295
 296         // This just eats empty options.
 297         do
 298         {
 299                 option = o->argv[o->optind];
 300                 if (option == NULL) return -1;
 301
 302                 empty = !strcmp(option, "");
 303                 o->optind += empty;
 304         }
 305         while (empty);
 306
 307         // If the option is just a "--".
 308         if (BC_OPT_ISDASHDASH(option))
 309         {
 310                 // Consume "--".
 311                 o->optind += 1;
 312                 return -1;
 313         }
 314         // Parse a short option.
 315         else if (BC_OPT_ISSHORTOPT(option)) return bc_opt_parseShort(o, longopts);
 316         // If the option is not long at this point, we are done.
 317         else if (!BC_OPT_ISLONGOPT(option)) return -1;
 318
 319         // Clear these.
 320         o->optopt = 0;
 321         o->optarg = NULL;
 322
 323         // Skip "--" at beginning of the option.
 324         option += 2;
 325         o->optind += 1;
 326
 327         // Loop through the valid long options.
 328         for (i = 0; !bc_opt_longoptsEnd(longopts, i); i++)
 329         {
 330                 const char* name = longopts[i].name;
 331
 332                 // If we have a match...
 333                 if (bc_opt_longoptsMatch(name, option))
 334                 {
 335                         char* arg;
 336
 337                         // Get the option char and the argument.
 338                         o->optopt = longopts[i].val;
 339                         arg = bc_opt_longoptsArg(option);
 340
 341                         // Error if the option is invalid..
 342                         if ((longopts[i].type == BC_OPT_BC_ONLY && BC_IS_DC) ||
 343                             (longopts[i].type == BC_OPT_REQUIRED_BC_ONLY && BC_IS_DC) ||
 344                             (longopts[i].type == BC_OPT_DC_ONLY && BC_IS_BC))
 345                         {
 346                                 bc_opt_error(BC_ERR_FATAL_OPTION, o->optopt, name, false);
 347                         }
 348
 349                         // Error if we have an argument and should not.
 350                         if (longopts[i].type == BC_OPT_NONE && arg != NULL)
 351                         {
 352                                 bc_opt_error(BC_ERR_FATAL_OPTION_ARG, o->optopt, name, false);
 353                         }
 354
 355                         // Set the argument, or check the next argument if we don't have
 356                         // one.
 357                         if (arg != NULL) o->optarg = arg;
 358                         else if (longopts[i].type == BC_OPT_REQUIRED ||
 359                                  longopts[i].type == BC_OPT_REQUIRED_BC_ONLY)
 360                         {
 361                                 // Get the next argument.
 362                                 o->optarg = o->argv[o->optind];
 363
 364                                 // All's good if it exists; otherwise, barf.
 365                                 if (o->optarg != NULL) o->optind += 1;
 366                                 else
 367                                 {
 368                                         bc_opt_error(BC_ERR_FATAL_OPTION_NO_ARG, o->optopt, name,
 369                                                      false);
 370                                 }
 371                         }
 372
 373                         return o->optopt;
 374                 }
 375         }
 376
 377         // If we reach this point, the option is invalid.
 378         bc_opt_error(BC_ERR_FATAL_OPTION, 0, option, false);
 379
 380         BC_UNREACHABLE
 381
 382 #if !BC_CLANG
 383         return -1;
 384 #endif // !BC_CLANG
 385 }
 386
 387 void
 388 bc_opt_init(BcOpt* o, char* argv[])
 389 {
 390         o->argv = argv;
 391         o->optind = 1;
 392         o->subopt = 0;
 393         o->optarg = NULL;
 394 }