lib/arg.c

   1 /* arg.c - argument parser */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2003,2004,2005,2007,2008  Free Software Foundation, Inc.
   5  *
   6  *  GRUB 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  *  GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/misc.h>
  21 #include <grub/mm.h>
  22 #include <grub/err.h>
  23 #include <grub/term.h>
  24 #include <grub/extcmd.h>
  25
  26 /* Built-in parser for default options.  */
  27 #define SHORT_ARG_HELP  -100
  28 #define SHORT_ARG_USAGE -101
  29
  30 static const struct grub_arg_option help_options[] =
  31   {
  32     {"help", SHORT_ARG_HELP, 0,
  33      "display this help and exit", 0, ARG_TYPE_NONE},
  34     {"usage", SHORT_ARG_USAGE, 0,
  35      "display the usage of this command and exit", 0, ARG_TYPE_NONE},
  36     {0, 0, 0, 0, 0, 0}
  37   };
  38
  39 static struct grub_arg_option *
  40 find_short (const struct grub_arg_option *options, char c)
  41 {
  42   struct grub_arg_option *found = 0;
  43   auto struct grub_arg_option *fnd_short (const struct grub_arg_option *opt);
  44
  45   struct grub_arg_option *fnd_short (const struct grub_arg_option *opt)
  46     {
  47       while (opt->doc)
  48         {
  49           if (opt->shortarg == c)
  50             return (struct grub_arg_option *) opt;
  51           opt++;
  52         }
  53       return 0;
  54     }
  55
  56   if (options)
  57     found = fnd_short (options);
  58
  59   if (! found)
  60     {
  61       switch (c)
  62         {
  63         case 'h':
  64           found = (struct grub_arg_option *) help_options;
  65           break;
  66
  67         case 'u':
  68           found = (struct grub_arg_option *) (help_options + 1);
  69           break;
  70
  71         default:
  72           break;
  73         }
  74     }
  75
  76   return found;
  77 }
  78
  79 static struct grub_arg_option *
  80 find_long (const struct grub_arg_option *options, const char *s, int len)
  81 {
  82   struct grub_arg_option *found = 0;
  83   auto struct grub_arg_option *fnd_long (const struct grub_arg_option *opt);
  84
  85   struct grub_arg_option *fnd_long (const struct grub_arg_option *opt)
  86     {
  87       while (opt->doc)
  88         {
  89           if (opt->longarg && ! grub_strncmp (opt->longarg, s, len) &&
  90               opt->longarg[len] == '\0')
  91             return (struct grub_arg_option *) opt;
  92           opt++;
  93         }
  94       return 0;
  95     }
  96
  97   if (options)
  98     found = fnd_long (options);
  99
 100   if (! found)
 101     found = fnd_long (help_options);
 102
 103   return found;
 104 }
 105
 106 static void
 107 show_usage (grub_extcmd_t cmd)
 108 {
 109   grub_printf ("Usage: %s\n", cmd->cmd->summary);
 110 }
 111
 112 void
 113 grub_arg_show_help (grub_extcmd_t cmd)
 114 {
 115   auto void showargs (const struct grub_arg_option *opt);
 116   int h_is_used = 0;
 117   int u_is_used = 0;
 118
 119   auto void showargs (const struct grub_arg_option *opt)
 120     {
 121       for (; opt->doc; opt++)
 122         {
 123           int spacing = 20;
 124           const char *doc;
 125
 126           if (opt->shortarg && grub_isgraph (opt->shortarg))
 127             grub_printf ("-%c%c ", opt->shortarg, opt->longarg ? ',':' ');
 128           else if (opt->shortarg == SHORT_ARG_HELP && ! h_is_used)
 129             grub_printf ("-h, ");
 130           else if (opt->shortarg == SHORT_ARG_USAGE && ! u_is_used)
 131             grub_printf ("-u, ");
 132           else
 133             grub_printf ("    ");
 134
 135           if (opt->longarg)
 136             {
 137               grub_printf ("--%s", opt->longarg);
 138               spacing -= grub_strlen (opt->longarg) + 2;
 139
 140               if (opt->arg)
 141                 {
 142                   grub_printf ("=%s", opt->arg);
 143                   spacing -= grub_strlen (opt->arg) + 1;
 144                 }
 145             }
 146
 147           doc = opt->doc;
 148           for (;;)
 149             {
 150               while (spacing-- > 0)
 151                 grub_putchar (' ');
 152
 153               while (*doc && *doc != '\n')
 154                 grub_putchar (*doc++);
 155               grub_putchar ('\n');
 156
 157               if (! *doc)
 158                 break;
 159               doc++;
 160               spacing = 4 + 20;
 161             }
 162
 163           switch (opt->shortarg)
 164             {
 165             case 'h':
 166               h_is_used = 1;
 167               break;
 168
 169             case 'u':
 170               u_is_used = 1;
 171               break;
 172
 173             default:
 174               break;
 175             }
 176         }
 177     }
 178
 179   show_usage (cmd);
 180   grub_printf ("%s\n\n", cmd->cmd->description);
 181   if (cmd->options)
 182     showargs (cmd->options);
 183   showargs (help_options);
 184 #if 0
 185   grub_printf ("\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
 186 #endif
 187 }
 188
 189
 190 static int
 191 parse_option (grub_extcmd_t cmd, int key, char *arg, struct grub_arg_list *usr)
 192 {
 193   switch (key)
 194     {
 195     case SHORT_ARG_HELP:
 196       grub_arg_show_help (cmd);
 197       return -1;
 198
 199     case SHORT_ARG_USAGE:
 200       show_usage (cmd);
 201       return -1;
 202
 203     default:
 204       {
 205         int found = -1;
 206         int i = 0;
 207         const struct grub_arg_option *opt = cmd->options;
 208
 209         while (opt->doc)
 210           {
 211             if (opt->shortarg && key == opt->shortarg)
 212               {
 213                 found = i;
 214                 break;
 215               }
 216             opt++;
 217             i++;
 218           }
 219
 220         if (found == -1)
 221           return -1;
 222
 223         usr[found].set = 1;
 224         usr[found].arg = arg;
 225       }
 226     }
 227
 228   return 0;
 229 }
 230
 231 int
 232 grub_arg_parse (grub_extcmd_t cmd, int argc, char **argv,
 233                 struct grub_arg_list *usr, char ***args, int *argnum)
 234 {
 235   int curarg;
 236   int arglen;
 237   int complete = 0;
 238   char **argl = 0;
 239   int num = 0;
 240   auto grub_err_t add_arg (char *s);
 241
 242   grub_err_t add_arg (char *s)
 243     {
 244       argl = grub_realloc (argl, (++num) * sizeof (char *));
 245       if (! argl)
 246         return grub_errno;
 247       argl[num - 1] = s;
 248       return 0;
 249     }
 250
 251
 252   for (curarg = 0; curarg < argc; curarg++)
 253     {
 254       char *arg = argv[curarg];
 255       struct grub_arg_option *opt;
 256       char *option = 0;
 257
 258       /* No option is used.  */
 259       if (arg[0] != '-' || grub_strlen (arg) == 1)
 260         {
 261           if (add_arg (arg) != 0)
 262             goto fail;
 263
 264           continue;
 265         }
 266
 267       /* One or more short options.  */
 268       if (arg[1] != '-')
 269         {
 270           char *curshort = arg + 1;
 271
 272           while (1)
 273             {
 274               opt = find_short (cmd->options, *curshort);
 275               if (! opt)
 276                 {
 277                   grub_error (GRUB_ERR_BAD_ARGUMENT,
 278                               "Unknown argument `-%c'\n", *curshort);
 279                   goto fail;
 280                 }
 281
 282               curshort++;
 283
 284               /* Parse all arguments here except the last one because
 285                  it can have an argument value.  */
 286               if (*curshort)
 287                 {
 288                   if (parse_option (cmd, opt->shortarg, 0, usr) || grub_errno)
 289                     goto fail;
 290                 }
 291               else
 292                 {
 293                   if (opt->type != ARG_TYPE_NONE)
 294                     {
 295                       if (curarg + 1 < argc)
 296                         {
 297                           char *nextarg = argv[curarg + 1];
 298                           if (!(opt->flags & GRUB_ARG_OPTION_OPTIONAL)
 299                               || (grub_strlen (nextarg) < 2 || nextarg[0] != '-'))
 300                             option = argv[++curarg];
 301                         }
 302                     }
 303                   break;
 304                 }
 305             }
 306
 307         }
 308       else /* The argument starts with "--".  */
 309         {
 310           /* If the argument "--" is used just pass the other
 311              arguments.  */
 312           if (grub_strlen (arg) == 2)
 313             {
 314               for (curarg++; curarg < argc; curarg++)
 315                 if (add_arg (argv[curarg]) != 0)
 316                   goto fail;
 317               break;
 318             }
 319
 320           option = grub_strchr (arg, '=');
 321           if (option) {
 322             arglen = option - arg - 2;
 323             option++;
 324           } else
 325             arglen = grub_strlen (arg) - 2;
 326
 327           opt = find_long (cmd->options, arg + 2, arglen);
 328           if (! opt)
 329             {
 330               grub_error (GRUB_ERR_BAD_ARGUMENT, "Unknown argument `%s'\n", arg);
 331               goto fail;
 332             }
 333         }
 334
 335       if (! (opt->type == ARG_TYPE_NONE
 336              || (! option && (opt->flags & GRUB_ARG_OPTION_OPTIONAL))))
 337         {
 338           if (! option)
 339             {
 340               grub_error (GRUB_ERR_BAD_ARGUMENT,
 341                           "Missing mandatory option for `%s'\n", opt->longarg);
 342               goto fail;
 343             }
 344
 345           switch (opt->type)
 346             {
 347             case ARG_TYPE_NONE:
 348               /* This will never happen.  */
 349               break;
 350
 351             case ARG_TYPE_STRING:
 352                   /* No need to do anything.  */
 353               break;
 354
 355             case ARG_TYPE_INT:
 356               {
 357                 char *tail;
 358
 359                 grub_strtoul (option, &tail, 0);
 360                 if (tail == 0 || tail == option || *tail != '\0' || grub_errno)
 361                   {
 362                     grub_error (GRUB_ERR_BAD_ARGUMENT,
 363                                 "The argument `%s' requires an integer.",
 364                                 arg);
 365
 366                     goto fail;
 367                   }
 368                 break;
 369               }
 370
 371             case ARG_TYPE_DEVICE:
 372             case ARG_TYPE_DIR:
 373             case ARG_TYPE_FILE:
 374             case ARG_TYPE_PATHNAME:
 375               /* XXX: Not implemented.  */
 376               break;
 377             }
 378           if (parse_option (cmd, opt->shortarg, option, usr) || grub_errno)
 379             goto fail;
 380         }
 381       else
 382         {
 383           if (option)
 384             {
 385               grub_error (GRUB_ERR_BAD_ARGUMENT,
 386                           "A value was assigned to the argument `%s' while it "
 387                           "doesn't require an argument\n", arg);
 388               goto fail;
 389             }
 390
 391           if (parse_option (cmd, opt->shortarg, 0, usr) || grub_errno)
 392             goto fail;
 393         }
 394     }
 395
 396   complete = 1;
 397
 398   *args = argl;
 399   *argnum = num;
 400
 401  fail:
 402   return complete;
 403 }