libbb/getopt_ulflags.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * universal getopt_ulflags implementation for busybox
   4  *
   5  * Copyright (C) 2003-2005  Vladimir Oleynik  <dzo@simtreas.ru>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  *
  21  */
  22
  23 #include <getopt.h>
  24 #include <string.h>
  25 #include <assert.h>
  26 #include <stdlib.h>
  27 #include "libbb.h"
  28
  29 /*                  Documentation !
  30
  31 unsigned long
  32 bb_getopt_ulflags (int argc, char **argv, const char *applet_opts, ...)
  33
  34         The command line options must be declared in const char
  35         *applet_opts as a string of chars, for example:
  36
  37         flags = bb_getopt_ulflags(argc, argv, "rnug");
  38
  39         If one of the given options is found, a flag value is added to
  40         the return value (an unsigned long).
  41
  42         The flag value is determined by the position of the char in
  43         applet_opts string.  For example, in the above case:
  44
  45         flags = bb_getopt_ulflags(argc, argv, "rnug");
  46
  47         "r" will add 1    (bit 1 : 0x01)
  48         "n" will add 2    (bit 2 : 0x02)
  49         "u  will add 4    (bit 3 : 0x03)
  50         "g" will add 8    (bit 4 : 0x04)
  51
  52          and so on.  You can also look at the return value as a bit
  53          field and each option sets one of bits.
  54
  55  ":"    If one of the options requires an argument, then add a ":"
  56         after the char in applet_opts and provide a pointer to store
  57         the argument.  For example:
  58
  59         char *pointer_to_arg_for_a;
  60         char *pointer_to_arg_for_b;
  61         char *pointer_to_arg_for_c;
  62         char *pointer_to_arg_for_d;
  63
  64         flags = bb_getopt_ulflags(argc, argv, "a:b:c:d:",
  65                          &pointer_to_arg_for_a, &pointer_to_arg_for_b,
  66                          &pointer_to_arg_for_c, &pointer_to_arg_for_d);
  67
  68         The type of the pointer (char* or llist_t *) may be controlled
  69         by the "*" special character that is set in the external string
  70         bb_opt_complementally (see below for more info).
  71
  72 static const struct option bb_default_long_options[]
  73
  74         This struct allows you to define long options.  The syntax for
  75         declaring the array is just like that of getopt's longopts.
  76         (see getopt(3))
  77
  78         static const struct option applet_long_options[] = {
  79                 { "verbose", 0, 0, v },
  80                 { 0, 0, 0, 0 }
  81         };
  82         bb_applet_long_options = applet_long_options;
  83
  84         The last argument (val) can undefined from applet_opts.
  85         If you use this, then:
  86         - return bit have next position after short options
  87         - if has_arg is not "no_argument", use ptr for arg also
  88         - bb_opt_complementally have effects for this too
  89
  90         Note: a good applet will make long options configurable via the
  91         config process and not a required feature.  The current standard
  92         is to name the config option CONFIG_FEATURE_<applet>_LONG_OPTIONS.
  93
  94 const char *bb_opt_complementally
  95
  96  ":"    The colon (":") is used to separate groups of two or more chars
  97         and/or groups of chars and special characters (stating some
  98         conditions to be checked).
  99
 100  "abc"  If groups of two or more chars are specified, the first char
 101         is the main option and the other chars are secondary options.
 102         Their flags will be turned on if the main option is found even
 103         if they are not specifed on the command line.  For example:
 104
 105         bb_opt_complementally = "abc";
 106
 107         flags = bb_getopt_ulflags(argc, argv, "abcd")
 108
 109         If getopt() finds "-a" on the command line, then
 110         bb_getopt_ulflags's return value will be as if "-a -b -c" were
 111         found.
 112
 113  "ww"   Adjacent double options have a counter associated which indicates
 114         the number of occurances of the option.
 115         For example the ps applet needs:
 116         if w is given once, GNU ps sets the width to 132,
 117         if w is given more than once, it is "unlimited"
 118
 119         int w_counter = 0;
 120         bb_opt_complementally = "ww";
 121         bb_getopt_ulflags(argc, argv, "w", &w_counter);
 122
 123         if(w_counter)
 124                 width = (w_counter == 1) ? 132 : INT_MAX;
 125         else
 126                 get_terminal_width(...&width...);
 127
 128         w_counter is a pointer to an integer. It has to be passed to
 129         bb_getopt_ulflags() after all other option argument sinks.
 130         For example: accept multiple -v to indicate the level of verbosity and
 131         for each -b optarg, add optarg to my_b. Finally, if b is given, turn off
 132         c and vice versa:
 133
 134         llist_t *my_b = NULL;
 135         int verbose_level = 0;
 136         bb_opt_complementally = "vv:b*:b-c:c-b";
 137         f = bb_getopt_ulflags(argc, argv, "vb:c", &my_b, &verbose_level);
 138         if((f & 2))     // -c after -b unset this -b flag
 139           while (my_b) { dosomething_with(my_b->data) ; my_b = my_b->link; }
 140         if(my_b)        // but llist stored always if -b found
 141                 free_llist(my_b);
 142         if (verbose_level) bb_printf("verbose level is %d\n", verbose_level);
 143
 144 Special characters:
 145
 146  "-"    A dash between two options causes the second of the two
 147         to be unset (and ignored or triggered) if it is given on
 148         the command line.
 149
 150         For example:
 151         The du applet has the options "-s" and "-d depth".  If
 152         bb_getopt_ulflags finds -s, then -d is unset or if it finds -d
 153         then -s is unset.  (Note:  busybox implements the GNU
 154         "--max-depth" option as "-d".)  To obtain this behavior, you
 155         set bb_opt_complementally = "s-d:d-s".  Only one flag value is
 156         added to bb_getopt_ulflags's return value depending on the
 157         position of the options on the command line.  If one of the
 158         two options requires an argument pointer (":" in applet_opts
 159         as in "d:") optarg is set accordingly.
 160
 161         char *smax_print_depth;
 162
 163         bb_opt_complementally = "s-d:d-s:x-x";
 164         opt = bb_getopt_ulflags(argc, argv, "sd:x", &smax_print_depth);
 165
 166         if (opt & 2) {
 167                  max_print_depth = bb_xgetularg10_bnd(smax_print_depth,
 168                              0, INT_MAX);
 169         }
 170         if(opt & 4)
 171                 printf("Detected odd -x usaging\n");
 172
 173  "-"    A minus as the first char in a bb_opt_complementally group means to
 174         convert the arguments as option.
 175         For example:
 176
 177         bb_opt_complementally = "-:w-x:x-w";
 178         bb_getopt_ulflags(argc, argv, "wx");
 179
 180         Allows any arguments to be given without a dash (./program w x)
 181         as well as with a dash (./program -x). Why unset -w see above.
 182
 183  "~"    A tilde between two options, or between an option and a group
 184         of options, means that they are mutually exclusive.  Unlike
 185         the "-" case above, an error will be forced if the options
 186         are used together.
 187
 188         For example:
 189         The cut applet must have only one type of list specified, so
 190         -b, -c and -f are mutally exclusive and should raise an error
 191         if specified together.  In this case you must set
 192         bb_opt_complementally = "b~cf:c~bf:f~bc".  If two of the
 193         mutually exclusive options are found, bb_getopt_ulflags's
 194         return value will have the error flag set (BB_GETOPT_ERROR) so
 195         that we can check for it:
 196
 197         if (flags & BB_GETOPT_ERROR)
 198                 bb_show_usage();
 199
 200  "!"    If previous point set BB_GETOPT_ERROR, don`t return and call
 201         previous example internally
 202
 203  "*"    A star after a char in bb_opt_complementally means that the
 204         option can occur multiple times:
 205
 206         For example:
 207         The grep applet can have one or more "-e pattern" arguments.
 208         In this case you should use bb_getopt_ulflags() as follows:
 209
 210         llist_t *patterns = NULL;
 211
 212         (this pointer must be initializated to NULL if the list is empty
 213         as required by *llist_add_to(llist_t *old_head, char *new_item).)
 214
 215         bb_opt_complementally = "e*";
 216
 217         bb_getopt_ulflags(argc, argv, "e:", &patterns);
 218         $ grep -e user -e root /etc/passwd
 219         root:x:0:0:root:/root:/bin/bash
 220         user:x:500:500::/home/user:/bin/bash
 221 */
 222
 223 const char *bb_opt_complementally;
 224
 225 typedef struct {
 226         unsigned char opt;
 227         char list_flg;
 228         unsigned long switch_on;
 229         unsigned long switch_off;
 230         unsigned long incongruously;
 231         void **optarg;               /* char **optarg or llist_t **optarg */
 232         int *counter;
 233 } t_complementally;
 234
 235 /* You can set bb_applet_long_options for parse called long options */
 236
 237 static const struct option bb_default_long_options[] = {
 238 /*      { "help", 0, NULL, '?' }, */
 239         { 0, 0, 0, 0 }
 240 };
 241
 242 const struct option *bb_applet_long_options = bb_default_long_options;
 243
 244 unsigned long
 245 bb_getopt_ulflags (int argc, char **argv, const char *applet_opts, ...)
 246 {
 247         unsigned long flags = 0;
 248         t_complementally complementally[sizeof(flags) * 8 + 1];
 249         int c;
 250         const unsigned char *s;
 251         t_complementally *on_off;
 252         va_list p;
 253         const struct option *l_o;
 254         char flg_show_usage_if_error = 0;
 255         char flg_argv_is_opts = 0;
 256         unsigned long trigger;
 257         char **pargv = NULL;
 258
 259         va_start (p, applet_opts);
 260
 261         /* skip GNU extension */
 262         s = applet_opts;
 263         if(*s == '+' || *s == '-')
 264                 s++;
 265
 266         c = 0;
 267         on_off = complementally;
 268         for (; *s; s++) {
 269                 if(c >= (int)(sizeof(flags)*8))
 270                         break;
 271                 on_off->opt = *s;
 272                 on_off->switch_on = (1 << c);
 273                 on_off->list_flg = 0;
 274                 on_off->switch_off = 0;
 275                 on_off->incongruously = 0;
 276                 on_off->optarg = NULL;
 277                 on_off->counter = NULL;
 278                 if (s[1] == ':') {
 279                         on_off->optarg = va_arg (p, void **);
 280                         do
 281                                 s++;
 282                         while (s[1] == ':');
 283                 }
 284                 on_off++;
 285                 c++;
 286         }
 287         on_off->opt = 0;
 288
 289         for(l_o = bb_applet_long_options; l_o->name; l_o++) {
 290                 for(on_off = complementally; on_off->opt != 0; on_off++)
 291                         if(on_off->opt == l_o->val)
 292                                 break;
 293                 if(on_off->opt == 0) {
 294                         if(c >= (int)(sizeof(flags)*8))
 295                                 break;
 296                         on_off->opt = l_o->val;
 297                         on_off->switch_on = (1 << c);
 298                         on_off->list_flg = 0;
 299                         on_off->switch_off = 0;
 300                         on_off->incongruously = 0;
 301                         on_off->counter = NULL;
 302                         if(l_o->has_arg != no_argument)
 303                                 on_off->optarg = va_arg (p, void **);
 304                         else
 305                                 on_off->optarg = NULL;
 306                         on_off++;
 307                         on_off->opt = 0;
 308                         c++;
 309                 }
 310         }
 311         c = 0;
 312         for (s = bb_opt_complementally; s && *s; s++) {
 313                 t_complementally *pair;
 314
 315                 if (*s == ':') {
 316                         c = 0;
 317                         continue;
 318                 }
 319                 if (c)
 320                         continue;
 321                 if(*s == '!') {
 322                         flg_show_usage_if_error = '!';
 323                         continue;
 324                 }
 325                 if(*s == '-') {
 326                         flg_argv_is_opts = '-';
 327                         continue;
 328                 }
 329                 for (on_off = complementally; on_off->opt; on_off++)
 330                         if (on_off->opt == *s)
 331                                 break;
 332                 pair = on_off;
 333                 for(s++; *s && *s != ':'; s++) {
 334                         if (*s == '-' || *s == '~') {
 335                                 c = *s;
 336                         } else if(*s == '*') {
 337                                 pair->list_flg++;
 338                         } else {
 339                             unsigned long *pair_switch = &(pair->switch_on);
 340                             if(c)
 341                                 pair_switch = c == '-' ? &(pair->switch_off) : &(pair->incongruously);
 342                             for (on_off = complementally; on_off->opt; on_off++)
 343                                 if (on_off->opt == *s) {
 344                                     if(pair_switch == &(on_off->switch_on))
 345                                         on_off->counter = va_arg (p, int *);
 346                                     else
 347                                         *pair_switch |= on_off->switch_on;
 348                                     break;
 349                                 }
 350                         }
 351                 }
 352                 s--;
 353         }
 354
 355         while ((c = getopt_long (argc, argv, applet_opts,
 356                                  bb_applet_long_options, NULL)) > 0) {
 357
 358 loop_arg_is_opt:
 359                 for (on_off = complementally; on_off->opt != c; on_off++) {
 360                         if(!on_off->opt)
 361                                 bb_show_usage ();
 362                 }
 363                 if(flags & on_off->incongruously) {
 364                         if(flg_show_usage_if_error)
 365                                 bb_show_usage ();
 366                         flags |= BB_GETOPT_ERROR;
 367                 }
 368                 trigger = on_off->switch_on & on_off->switch_off;
 369                 flags &= ~(on_off->switch_off ^ trigger);
 370                 flags |= on_off->switch_on ^ trigger;
 371                 flags ^= trigger;
 372                 if(on_off->counter)
 373                         (*(on_off->counter))++;
 374                 if(on_off->list_flg) {
 375                         *(llist_t **)(on_off->optarg) =
 376                           llist_add_to(*(llist_t **)(on_off->optarg), optarg);
 377                 } else if (on_off->optarg) {
 378                         *(char **)(on_off->optarg) = optarg;
 379                 }
 380                 if(flg_argv_is_opts == 'p')
 381                         break;
 382         }
 383         if(flg_argv_is_opts) {
 384                 /* process argv is option, for example "ps" applet */
 385                 if(flg_argv_is_opts == '-') {
 386                         flg_argv_is_opts = 'p';
 387                         pargv = argv + optind;
 388                 }
 389                 while(*pargv) {
 390                         c = **pargv;
 391                         if(c == '\0') {
 392                                 pargv++;
 393                         } else {
 394                                 (*pargv)++;
 395                                 goto loop_arg_is_opt;
 396                         }
 397                 }
 398         }
 399
 400         return flags;
 401 }