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