The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /*

 ** File:          plgetopt.c

 ** Description:   utilities to parse argc/argv

 */

 #include "prmem.h"

 #include "prlog.h"

 #include "prerror.h"

 #include "plstr.h"

 #include "plgetopt.h"

 #include <string.h>

 static char static_Nul = 0;

 struct PLOptionInternal

 {

     const char *options;        /* client options list specification */

     PRIntn argc;                /* original number of arguments */

     char **argv;                /* vector of pointers to arguments */

     PRIntn xargc;               /* which one we're processing now */

     const char *xargv;          /* where within *argv[xargc] */

     PRIntn minus;               /* do we already have the '-'? */

     const PLLongOpt *longOpts;  /* Caller's array */

     PRBool endOfOpts;           /* have reached a "--" argument */

     PRIntn optionsLen;          /* is strlen(options) */

 };

 /*

 ** Create the state in which to parse the tokens.

 **

 ** argc        the sum of the number of options and their values

 ** argv        the options and their values

 ** options    vector of single character options w/ | w/o ':

 */

 PR_IMPLEMENT(PLOptState*) PL_CreateOptState(

     PRIntn argc, char **argv, const char *options)

 {

     return PL_CreateLongOptState( argc, argv, options, NULL);

 }  /* PL_CreateOptState */

 PR_IMPLEMENT(PLOptState*) PL_CreateLongOptState(

     PRIntn argc, char **argv, const char *options, 

     const PLLongOpt *longOpts)

 {

     PLOptState *opt = NULL;

     PLOptionInternal *internal;

     if (NULL == options) 

     {

         PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);

         return opt;

     }

     opt = PR_NEWZAP(PLOptState);

     if (NULL == opt) 

     {

         PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);

         return opt;

     }

     internal = PR_NEW(PLOptionInternal);

     if (NULL == internal)

     {

         PR_DELETE(opt);

         PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);

         return NULL;

     }

     opt->option = 0;

     opt->value = NULL;

     opt->internal = internal;

     opt->longOption   =  0;

     opt->longOptIndex = -1;

     internal->argc = argc;

     internal->argv = argv;

     internal->xargc = 0;

     internal->xargv = &static_Nul;

     internal->minus = 0;

     internal->options = options;

     internal->longOpts = longOpts;

     internal->endOfOpts = PR_FALSE;

     internal->optionsLen = PL_strlen(options);

     return opt;

 }  /* PL_CreateLongOptState */

 /*

 ** Destroy object created by CreateOptState()

 */

 PR_IMPLEMENT(void) PL_DestroyOptState(PLOptState *opt)

 {

     PR_DELETE(opt->internal);

     PR_DELETE(opt);

 }  /* PL_DestroyOptState */

 PR_IMPLEMENT(PLOptStatus) PL_GetNextOpt(PLOptState *opt)

 {

     PLOptionInternal *internal = opt->internal;

     opt->longOption   =  0;

     opt->longOptIndex = -1;

     /*

     ** If the current xarg points to nul, advance to the next

     ** element of the argv vector. If the vector index is equal

     ** to argc, we're out of arguments, so return an EOL.

     ** Note whether the first character of the new argument is

     ** a '-' and skip by it if it is.

     */

     while (0 == *internal->xargv)

     {

         internal->xargc += 1;

         if (internal->xargc >= internal->argc)

         {

             opt->option = 0;

             opt->value = NULL;

             return PL_OPT_EOL;

         }

         internal->xargv = internal->argv[internal->xargc];

         internal->minus = 0;

         if (!internal->endOfOpts && ('-' == *internal->xargv)) 

         {

             internal->minus++;

             internal->xargv++;  /* and consume */

             if ('-' == *internal->xargv && internal->longOpts) 

             {

                 internal->minus++;

                 internal->xargv++;

                 if (0 == *internal->xargv) 

                 {

                     internal->endOfOpts = PR_TRUE;

                 }

             }

         }

     }

     /*

     ** If we already have a '-' or '--' in hand, xargv points to the next

     ** option. See if we can find a match in the list of possible

     ** options supplied.

     */

     if (internal->minus == 2) 

     {

         char * foundEqual = strchr(internal->xargv,'=');

         PRIntn optNameLen = foundEqual ? (foundEqual - internal->xargv) :

                             strlen(internal->xargv);

         const PLLongOpt *longOpt = internal->longOpts;

         PLOptStatus result = PL_OPT_BAD;

         opt->option = 0;

         opt->value  = NULL;

         for (; longOpt->longOptName; ++longOpt) 

         {

             if (strncmp(longOpt->longOptName, internal->xargv, optNameLen))

                 continue;  /* not a possible match */

             if (strlen(longOpt->longOptName) != optNameLen)

                 continue;  /* not a match */

             /* option name match */

             opt->longOptIndex = longOpt - internal->longOpts;

             opt->longOption   = longOpt->longOption;

             /* value is part of the current argv[] element if = was found */

             /* note: this sets value even for long options that do not

              * require option if specified as --long=value */

             if (foundEqual) 

             {

                 opt->value = foundEqual + 1;

             }

             else if (longOpt->valueRequired)

             {

                 /* value is the next argv[] element, if any */

                 if (internal->xargc + 1 < internal->argc)

                 {

                     opt->value = internal->argv[++(internal->xargc)];

                 }

                 /* missing value */

                 else

                 {

                     break; /* return PL_OPT_BAD */

                 }

             }

             result = PL_OPT_OK;

             break;

         }

         internal->xargv = &static_Nul; /* consume this */

         return result;

     }

     if (internal->minus)

     {

         PRIntn cop;

         PRIntn eoo = internal->optionsLen;

         for (cop = 0; cop < eoo; ++cop)

         {

             if (internal->options[cop] == *internal->xargv)

             {

                 opt->option = *internal->xargv++;

                 opt->longOption = opt->option & 0xff;

                 /*

                 ** if options indicates that there's an associated

                 ** value, it must be provided, either as part of this

                 ** argv[] element or as the next one

                 */

                 if (':' == internal->options[cop + 1])

                 {

                     /* value is part of the current argv[] element */

                     if (0 != *internal->xargv)

                     {

                         opt->value = internal->xargv;

                     }

                     /* value is the next argv[] element, if any */

                     else if (internal->xargc + 1 < internal->argc)

                     {

                         opt->value = internal->argv[++(internal->xargc)];

                     }

                     /* missing value */

                     else

                     {

                         return PL_OPT_BAD;

                     }

                     internal->xargv = &static_Nul;

                     internal->minus = 0;

                 }

                 else 

                     opt->value = NULL; 

                 return PL_OPT_OK;

             }

         }

         internal->xargv += 1;  /* consume that option */

         return PL_OPT_BAD;

     }

     /*

     ** No '-', so it must be a standalone value. The option is nul.

     */

     opt->value = internal->argv[internal->xargc];

     internal->xargv = &static_Nul;

     opt->option = 0;

     return PL_OPT_OK;

 }  /* PL_GetNextOpt */

 /* plgetopt.c */