subopt-helper.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 /**
  20  * \file subopt-helper.c
  21  *
  22  * \brief Compensates the suboption parsing code duplication a bit.
  23  *
  24  * The routines defined below are there to help you with the
  25  * suboption parsing. Meaning extracting the options and their
  26  * values for you and also outputting generic help message if
  27  * a parse error is encountered.
  28  *
  29  * Most stuff happens in the subopt_parse function: if you call it
  30  * it parses for the passed opts in the passed string. It calls some
  31  * extra functions for explicit argument parsing ( where the option
  32  * itself isn't the argument but a value given after the argument
  33  * delimiter ('='). It also calls your test function if you supplied
  34  * one.
  35  *
  36  */
  37
  38 #include "subopt-helper.h"
  39 #include "mp_msg.h"
  40
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <limits.h>
  44 #include <assert.h>
  45
  46 #ifndef MPDEBUG
  47   #define NDEBUG
  48 #endif
  49
  50
  51 static char const * parse_int( char const * const str, int * const valp )
  52 {
  53   char * endp;
  54
  55   assert( str && "parse_int(): str == NULL" );
  56
  57   *valp = (int)strtol( str, &endp, 0 );
  58
  59   /* nothing was converted */
  60   if ( str == endp ) { return NULL; }
  61
  62   return endp;
  63 }
  64
  65 static char const * parse_float( char const * const str, float * const valp )
  66 {
  67   char * endp;
  68
  69   assert( str && "parse_float(): str == NULL" );
  70
  71   *valp = strtod( str, &endp );
  72
  73   /* nothing was converted */
  74   if ( str == endp ) { return NULL; }
  75
  76   return endp;
  77 }
  78
  79 #define QUOTE_CHAR '%'
  80 static char const * parse_str( char const * str, strarg_t * const valp )
  81 {
  82   char const * match = strchr( str, ':' );
  83
  84   if (str[0] == QUOTE_CHAR) {
  85     int len = 0;
  86     str = &str[1];
  87     len = (int)strtol(str, (char **)&str, 0);
  88     if (!str || str[0] != QUOTE_CHAR || (len > strlen(str) - 1))
  89       return NULL;
  90     str = &str[1];
  91     match = &str[len];
  92   }
  93   else
  94   if (str[0] == '"') {
  95     str = &str[1];
  96     match = strchr(str, '"');
  97     if (!match)
  98       return NULL;
  99     valp->len = match - str;
 100     valp->str = str;
 101     return &match[1];
 102   }
 103   if ( !match )
 104     match = &str[strlen(str)];
 105
 106   // empty string or too long
 107   if ((match == str) || (match - str > INT_MAX))
 108     return NULL;
 109
 110   valp->len = match - str;
 111   valp->str = str;
 112
 113   return match;
 114 }
 115
 116
 117 /**
 118  * \brief Try to parse all options in str and fail if it was not possible.
 119  *
 120  * \param str Pointer to the zero terminated string to be parsed.
 121  * \param opts Pointer to a options array. The array must be terminated
 122  *             with an element having set name to NULL in its opt_t structure.
 123  *
 124  * \return The return value is zero if the string could be parsed
 125  *         else a non-zero value is returned.
 126  *
 127  */
 128 int subopt_parse( char const * const str, const opt_t * opts )
 129 {
 130   int parse_err = 0, idx;
 131   unsigned int parse_pos = 0;
 132
 133   if ( str )
 134   {
 135     while ( str[parse_pos] && !parse_err )
 136     {
 137       int next = 0;
 138
 139       idx = 0; // reset index for the below loop
 140       while ( opts[idx].name )
 141       {
 142         int opt_len;
 143         int substr_len;
 144
 145         // get length of the option we test against */
 146         opt_len = strlen( opts[idx].name );
 147
 148         // get length of the current substring of str */
 149         {
 150           char * delim, * arg_delim;
 151
 152           /* search nearest delimiter ( option or argument delimiter ) */
 153           delim = strchr( &str[parse_pos], ':' );
 154           arg_delim = strchr( &str[parse_pos], '=' );
 155
 156           if ( ( delim && arg_delim && delim > arg_delim ) ||
 157                delim == NULL )
 158           {
 159             delim = strchr( &str[parse_pos], '=' );
 160           }
 161
 162           substr_len = delim ? // is a delim present
 163                          delim - &str[parse_pos] : // yes
 164                          strlen( &str[parse_pos] ); // no, end of string
 165         }
 166
 167         //printf( "substr_len=%d, opt_len=%d\n", substr_len, opt_len );
 168
 169         /* Check if the length of the current option matches the *
 170          * length of the option we want to test again.           */
 171         if ( substr_len == opt_len )
 172 {
 173         /* check if option was activated/deactivated */
 174         if( strncmp( &str[parse_pos], opts[idx].name, opt_len ) == 0 )
 175         {
 176           /* option was found */
 177           next = 1;
 178
 179           assert( opts[idx].valp && "Need a pointer to store the arg!" );
 180
 181           /* type specific code */
 182           if ( opts[idx].type == OPT_ARG_BOOL )
 183           {
 184             /* Handle OPT_ARG_BOOL separately so *
 185              * the others can share code.        */
 186
 187             /* set option to true */
 188             *((int *)(opts[idx].valp)) = 1;
 189
 190             /* increment position */
 191             parse_pos += opt_len;
 192           }
 193           else
 194           {
 195             /* Type is not OPT_ARG_BOOL, means we have to parse *
 196              * for the arg delimiter character and eventually   *
 197              * call a test function.                            */
 198             char const * last;
 199
 200             /* increment position to check for arg */
 201             parse_pos += opt_len;
 202
 203             if ( str[parse_pos] != '=' )
 204             {
 205               parse_err = 1; break;
 206             }
 207
 208             /* '=' char was there, so let's move after it */
 209             ++parse_pos;
 210
 211             switch ( opts[idx].type )
 212             {
 213               case OPT_ARG_INT:
 214                 last = parse_int( &str[parse_pos],
 215                                   (int *)opts[idx].valp );
 216
 217                 break;
 218               case OPT_ARG_STR:
 219                 last = parse_str( &str[parse_pos],
 220                                   (strarg_t *)opts[idx].valp );
 221                 break;
 222               case OPT_ARG_MSTRZ:
 223                 {
 224                   char **valp = opts[idx].valp;
 225                   strarg_t tmp;
 226                   tmp.str = NULL;
 227                   tmp.len = 0;
 228                   last = parse_str( &str[parse_pos], &tmp );
 229                   free(*valp);
 230                   *valp = NULL;
 231                   if (tmp.str && tmp.len > 0) {
 232                     *valp = malloc(tmp.len + 1);
 233                     memcpy(*valp, tmp.str, tmp.len);
 234                     (*valp)[tmp.len] = 0;
 235                   }
 236                   break;
 237                 }
 238               case OPT_ARG_FLOAT:
 239                 last = parse_float( &str[parse_pos],
 240                                   (float *)opts[idx].valp );
 241                 break;
 242               default:
 243                 assert( 0 && "Arg type of suboption doesn't exist!" );
 244                 last = NULL; // break parsing!
 245             }
 246
 247             /* was the conversion succesful? */
 248             if ( !last )
 249             {
 250               parse_err = 1; break;
 251             }
 252
 253             /* make test if supplied */
 254             if ( opts[idx].test && !opts[idx].test( opts[idx].valp ) )
 255             {
 256               parse_err = 1; break;
 257             }
 258
 259             /* we succeded, set position */
 260             parse_pos = last - str;
 261           }
 262         }
 263  }
 264         else if (opts[idx].type == OPT_ARG_BOOL) {
 265             // check for no-<opt>
 266             for (char **p = (char *[]){"no-", "no", NULL}; *p; p++) {
 267                 if (substr_len == opt_len + strlen(*p) &&
 268                     !strncmp(str + parse_pos, *p, strlen(*p)) &&
 269                     !strncmp(str + parse_pos + strlen(*p), opts[idx].name, opt_len)) {
 270                     /* option was found but negated */
 271                     next = 1;
 272
 273                     /* set arg to false */
 274                     *((int *)(opts[idx].valp)) = 0;
 275
 276                     parse_pos += opt_len + strlen(*p);
 277                     break;
 278                 }
 279             }
 280         }
 281
 282         ++idx; // test against next option
 283
 284         /* break out of the loop, if this subopt is processed */
 285         if ( next ) { break; }
 286       }
 287
 288       /* if we had a valid suboption the current pos should *
 289        * equal the delimiter char, which should be ':' for  *
 290        * suboptions.                                        */
 291       if ( !parse_err && str[parse_pos] == ':' ) { ++parse_pos; }
 292       else if ( str[parse_pos] ) { parse_err = 1; }
 293     }
 294   }
 295
 296   /* if an error was encountered */
 297   if (parse_err)
 298   {
 299     unsigned int i;
 300     mp_msg( MSGT_VO, MSGL_FATAL, "Could not parse arguments at the position indicated below:\n%s\n", str );
 301     for ( i = 0; i < parse_pos; ++i )
 302     {
 303       mp_msg(MSGT_VO, MSGL_FATAL, " ");
 304     }
 305     mp_msg(MSGT_VO, MSGL_FATAL, "^\n");
 306
 307     return -1;
 308   }
 309
 310   /* we could parse everything */
 311   return 0;
 312 }
 313
 314
 315 /*** common test functions ***/
 316
 317 /** \brief Test if i is not negative */
 318 int int_non_neg(void *iptr)
 319 {
 320   int *i = iptr;
 321   return *i >= 0;
 322 }
 323 /** \brief Test if i is positive. */
 324 int int_pos(void *iptr)
 325 {
 326   int *i = iptr;
 327   return *i > 0;
 328 }
 329
 330 /*** little helpers */
 331
 332 /** \brief compare the stings just as strcmp does */
 333 int strargcmp(strarg_t *arg, const char *str) {
 334   int res = strncmp(arg->str, str, arg->len);
 335   if (!res && arg->len != strlen(str))
 336     res = arg->len - strlen(str);
 337   return res;
 338 }
 339
 340 /** \brief compare the stings just as strcasecmp does */
 341 int strargcasecmp(strarg_t *arg, char *str) {
 342   int res = strncasecmp(arg->str, str, arg->len);
 343   if (!res && arg->len != strlen(str))
 344     res = arg->len - strlen(str);
 345   return res;
 346 }