args.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <limits.h>
  14 #include "args.h"
  15
  16 #include "vpx/vpx_integer.h"
  17 #include "vpx_ports/msvc.h"
  18
  19 #if defined(__GNUC__)
  20 __attribute__((noreturn)) extern void die(const char *fmt, ...);
  21 #elif defined(_MSC_VER)
  22 __declspec(noreturn) extern void die(const char *fmt, ...);
  23 #else
  24 extern void die(const char *fmt, ...);
  25 #endif
  26
  27 struct arg arg_init(char **argv) {
  28   struct arg a;
  29
  30   a.argv = argv;
  31   a.argv_step = 1;
  32   a.name = NULL;
  33   a.val = NULL;
  34   a.def = NULL;
  35   return a;
  36 }
  37
  38 int arg_match(struct arg *arg_, const struct arg_def *def, char **argv) {
  39   struct arg arg;
  40
  41   if (!argv[0] || argv[0][0] != '-') return 0;
  42
  43   arg = arg_init(argv);
  44
  45   if (def->short_name && strlen(arg.argv[0]) == strlen(def->short_name) + 1 &&
  46       !strcmp(arg.argv[0] + 1, def->short_name)) {
  47     arg.name = arg.argv[0] + 1;
  48     arg.val = def->has_val ? arg.argv[1] : NULL;
  49     arg.argv_step = def->has_val ? 2 : 1;
  50   } else if (def->long_name) {
  51     const size_t name_len = strlen(def->long_name);
  52
  53     if (strlen(arg.argv[0]) >= name_len + 2 && arg.argv[0][1] == '-' &&
  54         !strncmp(arg.argv[0] + 2, def->long_name, name_len) &&
  55         (arg.argv[0][name_len + 2] == '=' ||
  56          arg.argv[0][name_len + 2] == '\0')) {
  57       arg.name = arg.argv[0] + 2;
  58       arg.val = arg.name[name_len] == '=' ? arg.name + name_len + 1 : NULL;
  59       arg.argv_step = 1;
  60     }
  61   }
  62
  63   if (arg.name && !arg.val && def->has_val)
  64     die("Error: option %s requires argument.\n", arg.name);
  65
  66   if (arg.name && arg.val && !def->has_val)
  67     die("Error: option %s requires no argument.\n", arg.name);
  68
  69   if (arg.name && (arg.val || !def->has_val)) {
  70     arg.def = def;
  71     *arg_ = arg;
  72     return 1;
  73   }
  74
  75   return 0;
  76 }
  77
  78 const char *arg_next(struct arg *arg) {
  79   if (arg->argv[0]) arg->argv += arg->argv_step;
  80
  81   return *arg->argv;
  82 }
  83
  84 char **argv_dup(int argc, const char **argv) {
  85   char **new_argv = malloc((argc + 1) * sizeof(*argv));
  86
  87   memcpy(new_argv, argv, argc * sizeof(*argv));
  88   new_argv[argc] = NULL;
  89   return new_argv;
  90 }
  91
  92 void arg_show_usage(FILE *fp, const struct arg_def *const *defs) {
  93   char option_text[40] = { 0 };
  94
  95   for (; *defs; defs++) {
  96     const struct arg_def *def = *defs;
  97     char *short_val = def->has_val ? " <arg>" : "";
  98     char *long_val = def->has_val ? "=<arg>" : "";
  99
 100     if (def->short_name && def->long_name) {
 101       char *comma = def->has_val ? "," : ",      ";
 102
 103       snprintf(option_text, 37, "-%s%s%s --%s%6s", def->short_name, short_val,
 104                comma, def->long_name, long_val);
 105     } else if (def->short_name)
 106       snprintf(option_text, 37, "-%s%s", def->short_name, short_val);
 107     else if (def->long_name)
 108       snprintf(option_text, 37, "          --%s%s", def->long_name, long_val);
 109
 110     fprintf(fp, "  %-37s\t%s\n", option_text, def->desc);
 111
 112     if (def->enums) {
 113       const struct arg_enum_list *listptr;
 114
 115       fprintf(fp, "  %-37s\t  ", "");
 116
 117       for (listptr = def->enums; listptr->name; listptr++)
 118         fprintf(fp, "%s%s", listptr->name, listptr[1].name ? ", " : "\n");
 119     }
 120   }
 121 }
 122
 123 unsigned int arg_parse_uint(const struct arg *arg) {
 124   uint32_t rawval;
 125   char *endptr;
 126
 127   rawval = (uint32_t)strtoul(arg->val, &endptr, 10);
 128
 129   if (arg->val[0] != '\0' && endptr[0] == '\0') {
 130     if (rawval <= UINT_MAX) return rawval;
 131
 132     die("Option %s: Value %ld out of range for unsigned int\n", arg->name,
 133         rawval);
 134   }
 135
 136   die("Option %s: Invalid character '%c'\n", arg->name, *endptr);
 137   return 0;
 138 }
 139
 140 int arg_parse_int(const struct arg *arg) {
 141   int32_t rawval;
 142   char *endptr;
 143
 144   rawval = (int32_t)strtol(arg->val, &endptr, 10);
 145
 146   if (arg->val[0] != '\0' && endptr[0] == '\0') {
 147     if (rawval >= INT_MIN && rawval <= INT_MAX) return (int)rawval;
 148
 149     die("Option %s: Value %ld out of range for signed int\n", arg->name,
 150         rawval);
 151   }
 152
 153   die("Option %s: Invalid character '%c'\n", arg->name, *endptr);
 154   return 0;
 155 }
 156
 157 struct vpx_rational {
 158   int num; /**< fraction numerator */
 159   int den; /**< fraction denominator */
 160 };
 161 struct vpx_rational arg_parse_rational(const struct arg *arg) {
 162   long int rawval;
 163   char *endptr;
 164   struct vpx_rational rat;
 165
 166   /* parse numerator */
 167   rawval = strtol(arg->val, &endptr, 10);
 168
 169   if (arg->val[0] != '\0' && endptr[0] == '/') {
 170     if (rawval >= INT_MIN && rawval <= INT_MAX)
 171       rat.num = (int)rawval;
 172     else
 173       die("Option %s: Value %ld out of range for signed int\n", arg->name,
 174           rawval);
 175   } else
 176     die("Option %s: Expected / at '%c'\n", arg->name, *endptr);
 177
 178   /* parse denominator */
 179   rawval = strtol(endptr + 1, &endptr, 10);
 180
 181   if (arg->val[0] != '\0' && endptr[0] == '\0') {
 182     if (rawval >= INT_MIN && rawval <= INT_MAX)
 183       rat.den = (int)rawval;
 184     else
 185       die("Option %s: Value %ld out of range for signed int\n", arg->name,
 186           rawval);
 187   } else
 188     die("Option %s: Invalid character '%c'\n", arg->name, *endptr);
 189
 190   return rat;
 191 }
 192
 193 int arg_parse_enum(const struct arg *arg) {
 194   const struct arg_enum_list *listptr;
 195   long int rawval;
 196   char *endptr;
 197
 198   /* First see if the value can be parsed as a raw value */
 199   rawval = strtol(arg->val, &endptr, 10);
 200   if (arg->val[0] != '\0' && endptr[0] == '\0') {
 201     /* Got a raw value, make sure it's valid */
 202     for (listptr = arg->def->enums; listptr->name; listptr++)
 203       if (listptr->val == rawval) return (int)rawval;
 204   }
 205
 206   /* Next see if it can be parsed as a string */
 207   for (listptr = arg->def->enums; listptr->name; listptr++)
 208     if (!strcmp(arg->val, listptr->name)) return listptr->val;
 209
 210   die("Option %s: Invalid value '%s'\n", arg->name, arg->val);
 211   return 0;
 212 }
 213
 214 int arg_parse_enum_or_int(const struct arg *arg) {
 215   if (arg->def->enums) return arg_parse_enum(arg);
 216   return arg_parse_int(arg);
 217 }