libdockapp/src/daargs.c

   1 /*
   2  * Copyright (c) 1999-2005 Alfredo K. Kojima, Alban G. Hertroys
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  17  * AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  18  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  19  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20  *
  21  */
  22
  23 #include <assert.h>
  24 #include <string.h>
  25
  26 #include "daargs.h"
  27 #include "dautil.h"
  28
  29 #define DEFAULT_OPTION_COUNT 3
  30
  31 extern struct DAContext *_daContext;
  32
  33 /*
  34  * Prototypes
  35  */
  36
  37 static void _daContextAddDefaultOptions(void);
  38 static void _daContextAddOptions(DAProgramOption *options, int count);
  39 static void printHelp(char *description);
  40
  41 int contains(char *needle, char *haystack);
  42 int parseOption(DAProgramOption *option, int i, int argc, char **argv);
  43 int readIntOption(int index, char **argv);
  44
  45 /*
  46  * Public functions
  47  */
  48
  49 void
  50 DAParseArguments(
  51         int argc,
  52         char **argv,
  53         DAProgramOption *options,
  54         int count,
  55         char *programDescription,
  56         char *versionDescription)
  57 {
  58         int i, j, size;
  59         int found = 0;
  60
  61         _daContext = DAContextInit();
  62
  63         _daContext->argc            = argc;
  64         _daContext->argv            = argv;
  65         _daContext->programName     = argv[0];
  66
  67         size = (count + DEFAULT_OPTION_COUNT) * sizeof(DAProgramOption *);
  68         _daContext->options         = malloc(size);
  69         memset(_daContext->options, 0, size);
  70
  71         _daContextAddDefaultOptions();
  72         _daContextAddOptions(options, count);
  73
  74         for (i = 1; i < argc; i++) {
  75                 char *optStr = argv[i];
  76
  77                 /* Handle default options */
  78                 if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
  79                         printHelp(programDescription), exit(0);
  80
  81                 if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0)
  82                         puts(versionDescription), exit(0);
  83
  84                 if (strcmp(argv[i], "-w") == 0 || strcmp(argv[i], "--windowed") == 0) {
  85                         _daContext->windowed = 1;
  86                         continue;
  87                 }
  88
  89                 found = 0;
  90                 /* options with a one-to-one mapping */
  91                 for (j = 0; j < count; j++) {
  92                         DAProgramOption *option = &options[j];
  93
  94                         if ((option->longForm && strcmp(option->longForm, optStr) == 0)
  95                             || (option->shortForm && strcmp(option->shortForm, optStr) == 0)) {
  96
  97                                 found = 1;
  98                                 i = parseOption(option, i, argc, argv);
  99                         }
 100                 }
 101
 102                 /* mixed options */
 103                 if (!found)
 104                         /* XXX: Parsing all options again... */
 105                         for (j = 0; j < count; j++) {
 106                                 DAProgramOption *option = &options[j];
 107
 108                                 if (option->shortForm && contains(option->shortForm, optStr)) {
 109                                         found = 1;
 110                                         i = parseOption(option, i, argc, argv);
 111                                 }
 112                         }
 113
 114                 if (!found) {
 115                         printf("%s: unrecognized option '%s'\n", argv[0], argv[i]);
 116                         printHelp(programDescription), exit(1);
 117                 }
 118         }
 119 }
 120
 121 int
 122 contains(char *needle, char *haystack)
 123 {
 124         char c, *pos;
 125
 126         assert(strlen(needle) == 2);
 127
 128         c = needle[1];
 129
 130         pos = strchr(haystack, c);
 131
 132         return (pos != NULL);
 133 }
 134
 135 int
 136 parseOption(DAProgramOption *option, int i, int argc, char **argv)
 137 {
 138         option->used = True;
 139
 140         if (option->type == DONone)
 141                 return i;
 142
 143         i++;
 144         if (i >= argc)
 145                 printf("%s: missing argument for option '%s'\n",
 146                        argv[0],
 147                        argv[i-1]),
 148                 exit(1);
 149
 150         switch (option->type) {
 151         case DOInteger:
 152                 *option->value.integer = readIntOption(i, argv);
 153
 154                 break;
 155
 156         case DONatural:
 157                 *option->value.integer = readIntOption(i, argv);
 158
 159                 if (*option->value.integer < 0)
 160                         printf("%s: argument %s must be >= 0\n",
 161                                argv[0],
 162                                argv[i-1]),
 163                         exit(1);
 164                 break;
 165
 166         case DOString:
 167                 *option->value.string = argv[i];
 168                 break;
 169         }
 170
 171         return i;
 172 }
 173
 174 int
 175 readIntOption(int index, char **argv)
 176 {
 177         int integer;
 178
 179         if (sscanf(argv[index], "%i", &integer) != 1)
 180                 DAError("error parsing argument for option %s\n", argv[index-1]),
 181                 exit(1);
 182
 183         return integer;
 184 }
 185
 186 int
 187 DAGetArgC()
 188 {
 189         return _daContext->argc;
 190 }
 191
 192 char **
 193 DAGetArgV()
 194 {
 195         return _daContext->argv;
 196 }
 197
 198 char *
 199 DAGetProgramName()
 200 {
 201         return _daContext->programName;
 202 }
 203
 204
 205 /*
 206  * Local functions
 207  */
 208
 209 struct DAContext *
 210 DAContextInit(void)
 211 {
 212         struct DAContext *context = malloc(sizeof(struct DAContext));
 213
 214         memset(context, 0, sizeof(struct DAContext));
 215
 216         return context;
 217 }
 218
 219 void
 220 DAFreeContext(void)
 221 {
 222         if (_daContext->optionCount > 0) {
 223                 int i;
 224
 225                 for (i = 0; i < _daContext->optionCount; i++)
 226                         free(_daContext->options[i]);
 227
 228                 free(_daContext->options);
 229         }
 230
 231         free(_daContext);
 232 }
 233
 234 static void
 235 _daContextAddOption(DAProgramOption *option)
 236 {
 237         /* If the buffer is full, double its size */
 238         if (sizeof(_daContext->options) == _daContext->optionCount * sizeof(DAProgramOption)) {
 239                 DAProgramOption **options;
 240
 241                 options = (DAProgramOption **)realloc(
 242                         (DAProgramOption **)_daContext->options,
 243                         2 * sizeof(_daContext->options));
 244
 245                 if (options == NULL)
 246                         DAError("Out of memory");
 247
 248                 _daContext->options = options;
 249         }
 250
 251         _daContext->options[_daContext->optionCount] = option;
 252         _daContext->optionCount++;
 253 }
 254
 255 static void
 256 _daContextAddOptionData(char *shortForm, char *longForm,
 257                         char *description, short type)
 258 {
 259         DAProgramOption *option = malloc(sizeof(DAProgramOption));
 260
 261         option->shortForm   = shortForm;
 262         option->longForm    = longForm;
 263         option->description = description;
 264         option->type        = type;
 265         option->used        = False;
 266         option->value.ptr   = NULL;
 267
 268         _daContextAddOption(option);
 269 }
 270
 271 static void
 272 _daContextAddDefaultOptions(void)
 273 {
 274         _daContextAddOptionData("-h", "--help", "show this help text and exit", DONone);
 275         _daContextAddOptionData("-v", "--version",  "show program version and exit", DONone);
 276         _daContextAddOptionData("-w", "--windowed", "run the application in windowed mode", DONone);
 277 }
 278
 279 static void
 280 _daContextAddOptions(DAProgramOption *options, int count)
 281 {
 282         int i;
 283
 284         for (i = 0; i < count; i++)
 285                 _daContextAddOptionData(
 286                         options[i].shortForm,
 287                         options[i].longForm,
 288                         options[i].description,
 289                         options[i].type);
 290 }
 291
 292 static void
 293 printHelp(char *description)
 294 {
 295         int i;
 296         DAProgramOption **options   = _daContext->options;
 297         int count                   = _daContext->optionCount;
 298
 299         printf("Usage: %s [OPTIONS]\n", _daContext->programName);
 300         if (description)
 301                 puts(description);
 302
 303         for (i = 0; i < count; i++) {
 304                 char blank[30];
 305                 int c;
 306
 307                 if (options[i]->shortForm && options[i]->longForm)
 308                         c = printf("  %s, %s", options[i]->shortForm, options[i]->longForm);
 309                 else if (options[i]->shortForm)
 310                         c = printf("  %s", options[i]->shortForm);
 311                 else if (options[i]->longForm)
 312                         c = printf("  %s", options[i]->longForm);
 313                 else
 314                         continue;
 315
 316                 if (options[i]->type != DONone) {
 317                         switch (options[i]->type) {
 318                         case DOInteger:
 319                                 c += printf(" <integer>");
 320                                 break;
 321                         case DOString:
 322                                 c += printf(" <string>");
 323                                 break;
 324                         case DONatural:
 325                                 c += printf(" <number>");
 326                                 break;
 327                         }
 328                 }
 329
 330                 memset(blank, ' ', 30);
 331                 if (c > 29)
 332                         c = 1;
 333                 blank[30-c] = 0;
 334                 printf("%s %s\n", blank, options[i]->description);
 335         }
 336 }
 337
 338
 339