apt-pkg/contrib/cmndline.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: cmndline.cc,v 1.13 2002/09/14 05:29:22 jgg Exp $
   4 /* ######################################################################
   5
   6    Command Line Class - Sophisticated command line parser
   7
   8    This source is placed in the Public Domain, do with it what you will
   9    It was originally written by Jason Gunthorpe <jgg@debian.org>.
  10
  11    ##################################################################### */
  12                                                                         /*}}}*/
  13 // Include files                                                        /*{{{*/
  14 #ifdef __GNUG__
  15 #pragma implementation "apt-pkg/cmndline.h"
  16 #endif
  17 #include <apt-pkg/cmndline.h>
  18 #include <apt-pkg/error.h>
  19 #include <apt-pkg/strutl.h>
  20
  21 #include <apti18n.h>
  22                                                                         /*}}}*/
  23
  24 // CommandLine::CommandLine - Constructor                               /*{{{*/
  25 // ---------------------------------------------------------------------
  26 /* */
  27 CommandLine::CommandLine(Args *AList,Configuration *Conf) : ArgList(AList),
  28                                  Conf(Conf), FileList(0)
  29 {
  30 }
  31                                                                         /*}}}*/
  32 // CommandLine::~CommandLine - Destructor                               /*{{{*/
  33 // ---------------------------------------------------------------------
  34 /* */
  35 CommandLine::~CommandLine()
  36 {
  37    delete [] FileList;
  38 }
  39                                                                         /*}}}*/
  40 // CommandLine::Parse - Main action member                              /*{{{*/
  41 // ---------------------------------------------------------------------
  42 /* */
  43 bool CommandLine::Parse(int argc,const char **argv)
  44 {
  45    delete [] FileList;
  46    FileList = new const char *[argc];
  47    const char **Files = FileList;
  48    int I;
  49    for (I = 1; I != argc; I++)
  50    {
  51       const char *Opt = argv[I];
  52
  53       // It is not an option
  54       if (*Opt != '-')
  55       {
  56          *Files++ = Opt;
  57          continue;
  58       }
  59
  60       Opt++;
  61
  62       // Double dash signifies the end of option processing
  63       if (*Opt == '-' && Opt[1] == 0)
  64       {
  65          I++;
  66          break;
  67       }
  68
  69       // Single dash is a short option
  70       if (*Opt != '-')
  71       {
  72          // Iterate over each letter
  73          while (*Opt != 0)
  74          {
  75             // Search for the option
  76             Args *A;
  77             for (A = ArgList; A->end() == false && A->ShortOpt != *Opt; A++);
  78             if (A->end() == true)
  79                return _error->Error(_("Command line option '%c' [from %s] is not known."),*Opt,argv[I]);
  80
  81             if (HandleOpt(I,argc,argv,Opt,A) == false)
  82                return false;
  83             if (*Opt != 0)
  84                Opt++;
  85          }
  86          continue;
  87       }
  88
  89       Opt++;
  90
  91       // Match up to a = against the list
  92       const char *OptEnd = Opt;
  93       Args *A;
  94       for (; *OptEnd != 0 && *OptEnd != '='; OptEnd++);
  95       for (A = ArgList; A->end() == false &&
  96            stringcasecmp(Opt,OptEnd,A->LongOpt) != 0; A++);
  97
  98       // Failed, look for a word after the first - (no-foo)
  99       bool PreceedMatch = false;
 100       if (A->end() == true)
 101       {
 102          for (; Opt != OptEnd && *Opt != '-'; Opt++);
 103
 104          if (Opt == OptEnd)
 105             return _error->Error(_("Command line option %s is not understood"),argv[I]);
 106          Opt++;
 107
 108          for (A = ArgList; A->end() == false &&
 109               stringcasecmp(Opt,OptEnd,A->LongOpt) != 0; A++);
 110
 111          // Failed again..
 112          if (A->end() == true && OptEnd - Opt != 1)
 113             return _error->Error(_("Command line option %s is not understood"),argv[I]);
 114
 115          // The option could be a single letter option prefixed by a no-..
 116          if (A->end() == true)
 117          {
 118             for (A = ArgList; A->end() == false && A->ShortOpt != *Opt; A++);
 119
 120             if (A->end() == true)
 121                return _error->Error(_("Command line option %s is not understood"),argv[I]);
 122          }
 123
 124          // The option is not boolean
 125          if (A->IsBoolean() == false)
 126             return _error->Error(_("Command line option %s is not boolean"),argv[I]);
 127          PreceedMatch = true;
 128       }
 129
 130       // Deal with it.
 131       OptEnd--;
 132       if (HandleOpt(I,argc,argv,OptEnd,A,PreceedMatch) == false)
 133          return false;
 134    }
 135
 136    // Copy any remaining file names over
 137    for (; I != argc; I++)
 138       *Files++ = argv[I];
 139    *Files = 0;
 140
 141    return true;
 142 }
 143                                                                         /*}}}*/
 144 // CommandLine::HandleOpt - Handle a single option including all flags  /*{{{*/
 145 // ---------------------------------------------------------------------
 146 /* This is a helper function for parser, it looks at a given argument
 147    and looks for specific patterns in the string, it gets tokanized
 148    -ruffly- like -*[yes|true|enable]-(o|longopt)[=][ ][argument] */
 149 bool CommandLine::HandleOpt(int &I,int argc,const char *argv[],
 150                             const char *&Opt,Args *A,bool PreceedMatch)
 151 {
 152    const char *Argument = 0;
 153    bool CertainArg = false;
 154    int IncI = 0;
 155
 156    /* Determine the possible location of an option or 0 if their is
 157       no option */
 158    if (Opt[1] == 0 || (Opt[1] == '=' && Opt[2] == 0))
 159    {
 160       if (I + 1 < argc && argv[I+1][0] != '-')
 161          Argument = argv[I+1];
 162
 163       // Equals was specified but we fell off the end!
 164       if (Opt[1] == '=' && Argument == 0)
 165          return _error->Error(_("Option %s requires an argument."),argv[I]);
 166       if (Opt[1] == '=')
 167          CertainArg = true;
 168
 169       IncI = 1;
 170    }
 171    else
 172    {
 173       if (Opt[1] == '=')
 174       {
 175          CertainArg = true;
 176          Argument = Opt + 2;
 177       }
 178       else
 179          Argument = Opt + 1;
 180    }
 181
 182    // Option is an argument set
 183    if ((A->Flags & HasArg) == HasArg)
 184    {
 185       if (Argument == 0)
 186          return _error->Error(_("Option %s requires an argument."),argv[I]);
 187       Opt += strlen(Opt);
 188       I += IncI;
 189
 190       // Parse a configuration file
 191       if ((A->Flags & ConfigFile) == ConfigFile)
 192          return ReadConfigFile(*Conf,Argument);
 193
 194       // Arbitary item specification
 195       if ((A->Flags & ArbItem) == ArbItem)
 196       {
 197          const char *J;
 198          for (J = Argument; *J != 0 && *J != '='; J++);
 199          if (*J == 0)
 200             return _error->Error(_("Option %s: Configuration item sepecification must have an =<val>."),argv[I]);
 201
 202          // = is trailing
 203          if (J[1] == 0)
 204          {
 205             if (I+1 >= argc)
 206                return _error->Error(_("Option %s: Configuration item sepecification must have an =<val>."),argv[I]);
 207             Conf->Set(string(Argument,J-Argument),string(argv[I++ +1]));
 208          }
 209          else
 210             Conf->Set(string(Argument,J-Argument),string(J+1));
 211
 212          return true;
 213       }
 214
 215       const char *I = A->ConfName;
 216       for (; *I != 0 && *I != ' '; I++);
 217       if (*I == ' ')
 218          Conf->Set(string(A->ConfName,0,I-A->ConfName),string(I+1) + Argument);
 219       else
 220          Conf->Set(A->ConfName,string(I) + Argument);
 221
 222       return true;
 223    }
 224
 225    // Option is an integer level
 226    if ((A->Flags & IntLevel) == IntLevel)
 227    {
 228       // There might be an argument
 229       if (Argument != 0)
 230       {
 231          char *EndPtr;
 232          unsigned long Value = strtol(Argument,&EndPtr,10);
 233
 234          // Conversion failed and the argument was specified with an =s
 235          if (EndPtr == Argument && CertainArg == true)
 236             return _error->Error(_("Option %s requires an integer argument, not '%s'"),argv[I],Argument);
 237
 238          // Conversion was ok, set the value and return
 239          if (EndPtr != 0 && EndPtr != Argument && *EndPtr == 0)
 240          {
 241             Conf->Set(A->ConfName,Value);
 242             Opt += strlen(Opt);
 243             I += IncI;
 244             return true;
 245          }
 246       }
 247
 248       // Increase the level
 249       Conf->Set(A->ConfName,Conf->FindI(A->ConfName)+1);
 250       return true;
 251    }
 252
 253    // Option is a boolean
 254    int Sense = -1;  // -1 is unspecified, 0 is yes 1 is no
 255
 256    // Look for an argument.
 257    while (1)
 258    {
 259       // Look at preceeding text
 260       char Buffer[300];
 261       if (Argument == 0)
 262       {
 263          if (PreceedMatch == false)
 264             break;
 265
 266          if (strlen(argv[I]) >= sizeof(Buffer))
 267             return _error->Error(_("Option '%s' is too long"),argv[I]);
 268
 269          // Skip the leading dash
 270          const char *J = argv[I];
 271          for (; *J != 0 && *J == '-'; J++);
 272
 273          const char *JEnd = J;
 274          for (; *JEnd != 0 && *JEnd != '-'; JEnd++);
 275          if (*JEnd != 0)
 276          {
 277             strncpy(Buffer,J,JEnd - J);
 278             Buffer[JEnd - J] = 0;
 279             Argument = Buffer;
 280             CertainArg = true;
 281          }
 282          else
 283             break;
 284       }
 285
 286       // Check for boolean
 287       Sense = StringToBool(Argument);
 288       if (Sense >= 0)
 289       {
 290          // Eat the argument
 291          if (Argument != Buffer)
 292          {
 293             Opt += strlen(Opt);
 294             I += IncI;
 295          }
 296          break;
 297       }
 298
 299       if (CertainArg == true)
 300          return _error->Error(_("Sense %s is not understood, try true or false."),Argument);
 301
 302       Argument = 0;
 303    }
 304
 305    // Indeterminate sense depends on the flag
 306    if (Sense == -1)
 307    {
 308       if ((A->Flags & InvBoolean) == InvBoolean)
 309          Sense = 0;
 310       else
 311          Sense = 1;
 312    }
 313
 314    Conf->Set(A->ConfName,Sense);
 315    return true;
 316 }
 317                                                                         /*}}}*/
 318 // CommandLine::FileSize - Count the number of filenames                /*{{{*/
 319 // ---------------------------------------------------------------------
 320 /* */
 321 unsigned int CommandLine::FileSize() const
 322 {
 323    unsigned int Count = 0;
 324    for (const char **I = FileList; I != 0 && *I != 0; I++)
 325       Count++;
 326    return Count;
 327 }
 328                                                                         /*}}}*/
 329 // CommandLine::DispatchArg - Do something with the first arg           /*{{{*/
 330 // ---------------------------------------------------------------------
 331 /* */
 332 bool CommandLine::DispatchArg(Dispatch *Map,bool NoMatch)
 333 {
 334    int I;
 335    for (I = 0; Map[I].Match != 0; I++)
 336    {
 337       if (strcmp(FileList[0],Map[I].Match) == 0)
 338       {
 339          bool Res = Map[I].Handler(*this);
 340          if (Res == false && _error->PendingError() == false)
 341             _error->Error("Handler silently failed");
 342          return Res;
 343       }
 344    }
 345
 346    // No matching name
 347    if (Map[I].Match == 0)
 348    {
 349       if (NoMatch == true)
 350          _error->Error(_("Invalid operation %s"),FileList[0]);
 351    }
 352
 353    return false;
 354 }
 355                                                                         /*}}}*/