subopt-helper.c

   1 /**
   2  * \file subopt-helper.c
   3  *
   4  * \brief Compensates the suboption parsing code duplication a bit.
   5  *
   6  * The routines defined below are there to help you with the
   7  * suboption parsing. Meaning extracting the options and their
   8  * values for you and also outputting generic help message if
   9  * a parse error is encountered.
  10  *
  11  * Most stuff happens in the subopt_parse function: if you call it
  12  * it parses for the passed opts in the passed string. It calls some
  13  * extra functions for explicit argument parsing ( where the option
  14  * itself isn't the argument but a value given after the argument
  15  * delimiter ('='). It also calls your test function if you supplied
  16  * one.
  17  *
  18  */
  19
  20 #include "subopt-helper.h"
  21 #include "mp_msg.h"
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <assert.h>
  26
  27 #ifndef MPDEBUG
  28   #define NDEBUG
  29 #endif
  30
  31 /* prototypes for argument parsing */
  32 static char const * parse_int( char const * const str, int * const valp );
  33 static char const * parse_str( char const * const str, strarg_t * const valp );
  34
  35 /**
  36  * \brief Try to parse all options in str and fail if it was not possible.
  37  *
  38  * \param str Pointer to the zero terminated string to be parsed.
  39  * \param opts Pointer to a options array. The array must be terminated
  40  *             with an element having set name to NULL in its opt_t structure.
  41  *
  42  * \return The return value is zero if the string could be parsed
  43  *         else a non-zero value is returned.
  44  *
  45  */
  46 int subopt_parse( char const * const str, opt_t * opts )
  47 {
  48   int parse_err = 0, idx;
  49   unsigned int parse_pos = 0;
  50
  51   /* Initialize set member to false.          *
  52    * It is set to true if it was found in str */
  53   for ( idx=0; opts[idx].name; ++idx )
  54   {
  55     opts[idx].set = 0;
  56   }
  57
  58   if ( str )
  59   {
  60     while ( str[parse_pos] && !parse_err )
  61     {
  62       int next = 0;
  63
  64       idx = 0; // reset index for the below loop
  65       while ( opts[idx].name )
  66       {
  67         int opt_len;
  68         int substr_len;
  69
  70         // get length of the option we test against */
  71         opt_len = strlen( opts[idx].name );
  72
  73         // get length of the current substring of str */
  74         {
  75           char * delim, * arg_delim;
  76
  77           /* search nearest delimiter ( option or argument delimiter ) */
  78           delim = strchr( &str[parse_pos], ':' );
  79           arg_delim = strchr( &str[parse_pos], '=' );
  80
  81           if ( ( delim && arg_delim && delim > arg_delim ) ||
  82                delim == NULL )
  83           {
  84             delim = strchr( &str[parse_pos], '=' );
  85           }
  86
  87           substr_len = delim ? // is a delim present
  88                          delim - &str[parse_pos] : // yes
  89                          strlen( &str[parse_pos] ); // no, end of string
  90         }
  91
  92         //printf( "substr_len=%d, opt_len=%d\n", substr_len, opt_len );
  93
  94         /* Check if the length of the current option matches the *
  95          * length of the option we want to test again.           */
  96         if ( substr_len == opt_len )
  97 {
  98         /* check if option was activated/deactivated */
  99         if( strncmp( &str[parse_pos], opts[idx].name, opt_len ) == 0 )
 100         {
 101           /* option was found */
 102           opts[idx].set = 1; next = 1;
 103
 104           assert( opts[idx].valp && "Need a pointer to store the arg!" );
 105
 106           /* type specific code */
 107           if ( opts[idx].type == OPT_ARG_BOOL )
 108           {
 109             /* Handle OPT_ARG_BOOL seperately so *
 110              * the others can share code.        */
 111
 112             /* set option to true */
 113             *((int *)(opts[idx].valp)) = 1;
 114
 115             /* increment position */
 116             parse_pos += opt_len;
 117           }
 118           else
 119           {
 120             /* Type is not OPT_ARG_BOOL, means we have to parse *
 121              * for the arg delimiter character and eventually   *
 122              * call a test function.                            */
 123             char const * last;
 124
 125             /* increment position to check for arg */
 126             parse_pos += opt_len;
 127
 128             if ( str[parse_pos] != '=' )
 129             {
 130               parse_err = 1; break;
 131             }
 132
 133             /* '=' char was there, so let's move after it */
 134             ++parse_pos;
 135
 136             switch ( opts[idx].type )
 137             {
 138               case OPT_ARG_INT:
 139                 last = parse_int( &str[parse_pos],
 140                                   (int *)opts[idx].valp );
 141
 142                 break;
 143               case OPT_ARG_STR:
 144                 last = parse_str( &str[parse_pos],
 145                                   (strarg_t *)opts[idx].valp );
 146                 break;
 147               default:
 148                 assert( 0 && "Arg type of suboption doesn't exist!" );
 149                 last = NULL; // break parsing!
 150             }
 151
 152             /* was the conversion succesful? */
 153             if ( !last )
 154             {
 155               parse_err = 1; break;
 156             }
 157
 158             /* make test if supplied */
 159             if ( opts[idx].test && !opts[idx].test( opts[idx].valp ) )
 160             {
 161               parse_err = 1; break;
 162             }
 163
 164             /* we succeded, set position */
 165             parse_pos = last - str;
 166           }
 167         }
 168 }
 169 else if ( substr_len == opt_len+2 )
 170 {
 171              if ( opts[idx].type == OPT_ARG_BOOL && // check for no<opt>
 172                   strncmp( &str[parse_pos], "no", 2 ) == 0 &&
 173                   strncmp( &str[parse_pos+2], opts[idx].name, opt_len ) == 0 )
 174         {
 175           /* option was found but negated */
 176           opts[idx].set = 1; next = 1;
 177
 178           /* set arg to false */
 179           *((int *)(opts[idx].valp)) = 0;
 180
 181           /* increment position */
 182           parse_pos += opt_len+2;
 183         }
 184 }
 185
 186         ++idx; // test against next option
 187
 188         /* break out of the loop, if this subopt is processed */
 189         if ( next ) { break; }
 190       }
 191
 192       /* if we had a valid suboption the current pos should *
 193        * equal the delimiter char, which should be ':' for  *
 194        * suboptions.                                        */
 195       if ( !parse_err && str[parse_pos] == ':' ) { ++parse_pos; }
 196       else if ( str[parse_pos] ) { parse_err = 1; }
 197     }
 198   }
 199
 200   /* if an error was encountered */
 201   if (parse_err)
 202   {
 203     unsigned int i;
 204     mp_msg( MSGT_VO, MSGL_FATAL, "Could not parse arguments at the position indicated below:\n%s\n", str );
 205     for ( i = 0; i < parse_pos; ++i )
 206     {
 207       mp_msg(MSGT_VO, MSGL_FATAL, " ");
 208     }
 209     mp_msg(MSGT_VO, MSGL_FATAL, "^\n");
 210
 211     return -1;
 212   }
 213
 214   /* we could parse everything */
 215   return 0;
 216 }
 217
 218 static char const * parse_int( char const * const str, int * const valp )
 219 {
 220   char * endp;
 221
 222   assert( str && "parse_int(): str == NULL" );
 223
 224   *valp = (int)strtol( str, &endp, 0 );
 225
 226   /* nothing was converted */
 227   if ( str == endp ) { return NULL; }
 228
 229   return endp;
 230 }
 231
 232 static char const * parse_str( char const * const str, strarg_t * const valp )
 233 {
 234   char const * match = strchr( str, ':' );
 235
 236   if ( !match )
 237     match = &str[strlen(str)];
 238
 239   // empty string or too long
 240   if ((match == str) || (match - str > 255))
 241     return NULL;
 242
 243   valp->len = match - str;
 244   valp->str = str;
 245
 246   return match;
 247 }