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 Special characters:
 114
 115  "-"    A dash between two options causes the second of the two
 116         to be unset (and ignored or triggered) if it is given on
 117         the command line.
 118
 119         For example:
 120         The du applet has the options "-s" and "-d depth".  If
 121         bb_getopt_ulflags finds -s, then -d is unset or if it finds -d
 122         then -s is unset.  (Note:  busybox implements the GNU
 123         "--max-depth" option as "-d".)  To obtain this behavior, you
 124         set bb_opt_complementally = "s-d:d-s".  Only one flag value is
 125         added to bb_getopt_ulflags's return value depending on the
 126         position of the options on the command line.  If one of the
 127         two options requires an argument pointer (":" in applet_opts
 128         as in "d:") optarg is set accordingly.
 129
 130         char *smax_print_depth;
 131
 132         bb_opt_complementally = "s-d:d-s:x-x";
 133         opt = bb_getopt_ulflags(argc, argv, "sd:x", &smax_print_depth);
 134
 135         if (opt & 2) {
 136                  max_print_depth = bb_xgetularg10_bnd(smax_print_depth,
 137                              0, INT_MAX);
 138         }
 139         if(opt & 4)
 140                 printf("Detected odd -x usaging\n");
 141
 142  "~"    A tilde between two options, or between an option and a group
 143         of options, means that they are mutually exclusive.  Unlike
 144         the "-" case above, an error will be forced if the options
 145         are used together.
 146
 147         For example:
 148         The cut applet must have only one type of list specified, so
 149         -b, -c and -f are mutally exclusive and should raise an error
 150         if specified together.  In this case you must set
 151         bb_opt_complementally = "b~cf:c~bf:f~bc".  If two of the
 152         mutually exclusive options are found, bb_getopt_ulflags's
 153         return value will have the error flag set (BB_GETOPT_ERROR) so
 154         that we can check for it:
 155
 156         if (flags & BB_GETOPT_ERROR)
 157                 bb_show_usage();
 158
 159  "!"    If previous point set BB_GETOPT_ERROR, don`t return and call
 160         previous example internally
 161
 162  "*"    A star after a char in bb_opt_complementally means that the
 163         option can occur multiple times:
 164
 165         For example:
 166         The grep applet can have one or more "-e pattern" arguments.
 167         In this case you should use bb_getopt_ulflags() as follows:
 168
 169         llist_t *patterns = NULL;
 170
 171         (this pointer must be initializated to NULL if the list is empty
 172         as required by *llist_add_to(llist_t *old_head, char *new_item).)
 173
 174         bb_opt_complementally = "e*";
 175
 176         bb_getopt_ulflags(argc, argv, "e:", &patterns);
 177         $ grep -e user -e root /etc/passwd
 178         root:x:0:0:root:/root:/bin/bash
 179         user:x:500:500::/home/user:/bin/bash
 180 */
 181
 182 const char *bb_opt_complementally;
 183
 184 typedef struct {
 185         unsigned char opt;
 186         char list_flg;
 187         unsigned long switch_on;
 188         unsigned long switch_off;
 189         unsigned long incongruously;
 190         void **optarg;               /* char **optarg or llist_t **optarg */
 191 } t_complementally;
 192
 193 /* You can set bb_applet_long_options for parse called long options */
 194
 195 static const struct option bb_default_long_options[] = {
 196 /*      { "help", 0, NULL, '?' }, */
 197         { 0, 0, 0, 0 }
 198 };
 199
 200 const struct option *bb_applet_long_options = bb_default_long_options;
 201
 202 unsigned long
 203 bb_getopt_ulflags (int argc, char **argv, const char *applet_opts, ...)
 204 {
 205         unsigned long flags = 0;
 206         t_complementally complementally[sizeof(flags) * 8 + 1];
 207         int c;
 208         const unsigned char *s;
 209         t_complementally *on_off;
 210         va_list p;
 211         const struct option *l_o;
 212         char flg_show_usage_if_error = 0;
 213
 214         va_start (p, applet_opts);
 215
 216         /* skip GNU extension */
 217         s = applet_opts;
 218         if(*s == '+' || *s == '-')
 219                 s++;
 220
 221         c = 0;
 222         on_off = complementally;
 223         for (; *s; s++) {
 224                 if(c >= (sizeof(flags)*8))
 225                         break;
 226                 on_off->opt = *s;
 227                 on_off->switch_on = (1 << c);
 228                 on_off->list_flg = 0;
 229                 on_off->switch_off = 0;
 230                 on_off->incongruously = 0;
 231                 on_off->optarg = NULL;
 232                 if (s[1] == ':') {
 233                         on_off->optarg = va_arg (p, void **);
 234                         do
 235                                 s++;
 236                         while (s[1] == ':');
 237                 }
 238                 on_off++;
 239                 c++;
 240         }
 241         on_off->opt = 0;
 242
 243         for(l_o = bb_applet_long_options; l_o->name; l_o++) {
 244                 for(on_off = complementally; on_off->opt != 0; on_off++)
 245                         if(on_off->opt == l_o->val)
 246                                 break;
 247                 if(on_off->opt == 0) {
 248                         if(c >= (sizeof(flags)*8))
 249                                 break;
 250                         on_off->opt = l_o->val;
 251                         on_off->switch_on = (1 << c);
 252                         on_off->list_flg = 0;
 253                         on_off->switch_off = 0;
 254                         on_off->incongruously = 0;
 255                         if(l_o->has_arg != no_argument)
 256                                 on_off->optarg = va_arg (p, void **);
 257                         else
 258                                 on_off->optarg = NULL;
 259                         on_off++;
 260                         on_off->opt = 0;
 261                         c++;
 262                 }
 263         }
 264         c = 0;
 265         for (s = bb_opt_complementally; s && *s; s++) {
 266                 t_complementally *pair;
 267
 268                 if (*s == ':') {
 269                         c = 0;
 270                         continue;
 271                 }
 272                 if (c)
 273                         continue;
 274                 if(*s == '!') {
 275                         flg_show_usage_if_error = '!';
 276                         continue;
 277                 }
 278                 for (on_off = complementally; on_off->opt; on_off++)
 279                         if (on_off->opt == *s)
 280                                 break;
 281                 pair = on_off;
 282                 for(s++; *s && *s != ':'; s++) {
 283                         if (*s == '-' || *s == '~') {
 284                                 c = *s;
 285                         } else if(*s == '*') {
 286                                 pair->list_flg++;
 287                         } else {
 288                                 unsigned long *pair_switch = &(pair->switch_on);
 289                                 if(c)
 290                                         pair_switch = c == '-' ? &(pair->switch_off) : &(pair->incongruously);
 291                                 for (on_off = complementally; on_off->opt; on_off++)
 292                                         if (on_off->opt == *s) {
 293                                                 *pair_switch |= on_off->switch_on;
 294                                                 break;
 295                                         }
 296                         }
 297                 }
 298                 s--;
 299         }
 300
 301         while ((c = getopt_long (argc, argv, applet_opts,
 302                                  bb_applet_long_options, NULL)) > 0) {
 303                 unsigned long trigger;
 304
 305                 for (on_off = complementally; on_off->opt != c; on_off++) {
 306                         if(!on_off->opt)
 307                                 bb_show_usage ();
 308                 }
 309                 if(flags & on_off->incongruously) {
 310                         if(flg_show_usage_if_error)
 311                                 bb_show_usage ();
 312                         flags |= BB_GETOPT_ERROR;
 313                 }
 314                 trigger = on_off->switch_on & on_off->switch_off;
 315                 flags &= ~(on_off->switch_off ^ trigger);
 316                 flags |= on_off->switch_on ^ trigger;
 317                 flags ^= trigger;
 318                 if(on_off->list_flg) {
 319                         *(llist_t **)(on_off->optarg) =
 320                                 llist_add_to(*(llist_t **)(on_off->optarg), optarg);
 321                 } else if (on_off->optarg) {
 322                         *(char **)(on_off->optarg) = optarg;
 323                 }
 324         }
 325
 326         return flags;
 327 }