[apt.git] / apt-pkg / contrib / cmndline.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: cmndline.cc,v 1.15 2003/02/10 01:40:58 doogie Exp $
/* ######################################################################

   Command Line Class - Sophisticated command line parser
   
   This source is placed in the Public Domain, do with it what you will
   It was originally written by Jason Gunthorpe <jgg@debian.org>.
   
   ##################################################################### */
									/*}}}*/
// Include files							/*{{{*/
#include<config.h>

#include <apt-pkg/configuration.h>
#include <apt-pkg/cmndline.h>
#include <apt-pkg/error.h>
#include <apt-pkg/strutl.h>

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <string>

#include <apti18n.h>
									/*}}}*/
using namespace std;

// CommandLine::CommandLine - Constructor				/*{{{*/
// ---------------------------------------------------------------------
/* */
CommandLine::CommandLine(Args *AList,Configuration *Conf) : ArgList(AList), 
                                 Conf(Conf), FileList(0)
{
}
									/*}}}*/
// CommandLine::~CommandLine - Destructor				/*{{{*/
// ---------------------------------------------------------------------
/* */
CommandLine::~CommandLine()
{
   delete [] FileList;
}
									/*}}}*/
// CommandLine::GetCommand - return the first non-option word		/*{{{*/
char const * CommandLine::GetCommand(Dispatch const * const Map,
      unsigned int const argc, char const * const * const argv)
{
   // if there is a -- on the line there must be the word we search for either
   // before it (as -- marks the end of the options) or right after it (as we can't
   // decide if the command is actually an option, given that in theory, you could
   // have parameters named like commands)
   for (size_t i = 1; i < argc; ++i)
   {
      if (strcmp(argv[i], "--") != 0)
	 continue;
      // check if command is before --
      for (size_t k = 1; k < i; ++k)
	 for (size_t j = 0; Map[j].Match != NULL; ++j)
	    if (strcmp(argv[k], Map[j].Match) == 0)
	       return Map[j].Match;
      // see if the next token after -- is the command
      ++i;
      if (i < argc)
	 for (size_t j = 0; Map[j].Match != NULL; ++j)
	    if (strcmp(argv[i], Map[j].Match) == 0)
	       return Map[j].Match;
      // we found a --, but not a command
      return NULL;
   }
   // no --, so search for the first word matching a command
   // FIXME: How like is it that an option parameter will be also a valid Match ?
   for (size_t i = 1; i < argc; ++i)
   {
      if (*(argv[i]) == '-')
	 continue;
      for (size_t j = 0; Map[j].Match != NULL; ++j)
	 if (strcmp(argv[i], Map[j].Match) == 0)
	    return Map[j].Match;
   }
   return NULL;
}
									/*}}}*/
// CommandLine::Parse - Main action member				/*{{{*/
// ---------------------------------------------------------------------
/* */
bool CommandLine::Parse(int argc,const char **argv)
{
   delete [] FileList;
   FileList = new const char *[argc];
   const char **Files = FileList;
   int I;
   for (I = 1; I != argc; I++)
   {
      const char *Opt = argv[I];
      
      // It is not an option
      if (*Opt != '-')
      {
	 *Files++ = Opt;
	 continue;
      }
      
      Opt++;
      
      // Double dash signifies the end of option processing
      if (*Opt == '-' && Opt[1] == 0)
      {
	 I++;
	 break;
      }
      
      // Single dash is a short option
      if (*Opt != '-')
      {
	 // Iterate over each letter
	 while (*Opt != 0)
	 {	    
	    // Search for the option
	    Args *A;
	    for (A = ArgList; A->end() == false && A->ShortOpt != *Opt; A++);
	    if (A->end() == true)
	       return _error->Error(_("Command line option '%c' [from %s] is not known."),*Opt,argv[I]);

	    if (HandleOpt(I,argc,argv,Opt,A) == false)
	       return false;
	    if (*Opt != 0)
	       Opt++;	       
	 }
	 continue;
      }
      
      Opt++;

      // Match up to a = against the list
      Args *A;
      const char *OptEnd = strchrnul(Opt, '=');
      for (A = ArgList; A->end() == false &&
	   (A->LongOpt == 0 || stringcasecmp(Opt,OptEnd,A->LongOpt) != 0);
	   ++A);
      
      // Failed, look for a word after the first - (no-foo)
      bool PreceedMatch = false;
      if (A->end() == true)
      {
         Opt = (const char*) memchr(Opt, '-', OptEnd - Opt);
	 if (Opt == NULL)
	    return _error->Error(_("Command line option %s is not understood"),argv[I]);
	 Opt++;
	 
	 for (A = ArgList; A->end() == false &&
	      (A->LongOpt == 0 || stringcasecmp(Opt,OptEnd,A->LongOpt) != 0);
	      ++A);

	 // Failed again..
	 if (A->end() == true && OptEnd - Opt != 1)
	    return _error->Error(_("Command line option %s is not understood"),argv[I]);

	 // The option could be a single letter option prefixed by a no-..
	 if (A->end() == true)
	 {
	    for (A = ArgList; A->end() == false && A->ShortOpt != *Opt; A++);
	    
	    if (A->end() == true)
	       return _error->Error(_("Command line option %s is not understood"),argv[I]);
	 }
	 
	 // The option is not boolean
	 if (A->IsBoolean() == false)
	    return _error->Error(_("Command line option %s is not boolean"),argv[I]);
	 PreceedMatch = true;
      }
      
      // Deal with it.
      OptEnd--;
      if (HandleOpt(I,argc,argv,OptEnd,A,PreceedMatch) == false)
	 return false;
   }
   
   // Copy any remaining file names over
   for (; I != argc; I++)
      *Files++ = argv[I];
   *Files = 0;

   SaveInConfig(argc, argv);

   return true;
}
									/*}}}*/
// CommandLine::HandleOpt - Handle a single option including all flags	/*{{{*/
// ---------------------------------------------------------------------
/* This is a helper function for parser, it looks at a given argument
   and looks for specific patterns in the string, it gets tokanized
   -ruffly- like -*[yes|true|enable]-(o|longopt)[=][ ][argument] */
bool CommandLine::HandleOpt(int &I,int argc,const char *argv[],
			    const char *&Opt,Args *A,bool PreceedMatch)
{
   const char *Argument = 0;
   bool CertainArg = false;
   int IncI = 0;

   /* Determine the possible location of an option or 0 if their is
      no option */
   if (Opt[1] == 0 || (Opt[1] == '=' && Opt[2] == 0))
   {
      if (I + 1 < argc && argv[I+1][0] != '-')
	 Argument = argv[I+1];
      
      // Equals was specified but we fell off the end!
      if (Opt[1] == '=' && Argument == 0)
	 return _error->Error(_("Option %s requires an argument."),argv[I]);
      if (Opt[1] == '=')
	 CertainArg = true;
	 
      IncI = 1;
   }
   else
   {
      if (Opt[1] == '=')
      {
	 CertainArg = true;
	 Argument = Opt + 2;
      }      
      else
	 Argument = Opt + 1;
   }
   
   // Option is an argument set
   if ((A->Flags & HasArg) == HasArg)
   {
      if (Argument == 0)
	 return _error->Error(_("Option %s requires an argument."),argv[I]);
      Opt += strlen(Opt);
      I += IncI;
      
      // Parse a configuration file
      if ((A->Flags & ConfigFile) == ConfigFile)
	 return ReadConfigFile(*Conf,Argument);

      // Arbitrary item specification
      if ((A->Flags & ArbItem) == ArbItem)
      {
	 const char *J = strchr(Argument, '=');
	 if (J == NULL)
	    return _error->Error(_("Option %s: Configuration item specification must have an =<val>."),argv[I]);

	 // = is trailing
	 if (J[1] == 0)
	 {
	    if (I+1 >= argc)
	       return _error->Error(_("Option %s: Configuration item specification must have an =<val>."),argv[I]);
	    Conf->Set(string(Argument,J-Argument),string(argv[I++ +1]));
	 }
	 else
	    Conf->Set(string(Argument,J-Argument),string(J+1));
	 
	 return true;
      }
      
      const char *I = strchrnul(A->ConfName, ' ');
      if (*I == ' ')
	 Conf->Set(string(A->ConfName,0,I-A->ConfName),string(I+1) + Argument);
      else
	 Conf->Set(A->ConfName,string(I) + Argument);
	 
      return true;
   }
   
   // Option is an integer level
   if ((A->Flags & IntLevel) == IntLevel)
   {
      // There might be an argument
      if (Argument != 0)
      {
	 char *EndPtr;
	 unsigned long Value = strtol(Argument,&EndPtr,10);
	 
	 // Conversion failed and the argument was specified with an =s
	 if (EndPtr == Argument && CertainArg == true)
	    return _error->Error(_("Option %s requires an integer argument, not '%s'"),argv[I],Argument);

	 // Conversion was ok, set the value and return
	 if (EndPtr != 0 && EndPtr != Argument && *EndPtr == 0)
	 {
	    Conf->Set(A->ConfName,Value);
	    Opt += strlen(Opt);
	    I += IncI;
	    return true;
	 }	 
      }      
      
      // Increase the level
      Conf->Set(A->ConfName,Conf->FindI(A->ConfName)+1);
      return true;
   }
  
   // Option is a boolean
   int Sense = -1;  // -1 is unspecified, 0 is yes 1 is no

   // Look for an argument.
   while (1)
   {
      // Look at preceding text
      char Buffer[300];
      if (Argument == 0)
      {
	 if (PreceedMatch == false)
	    break;
	 
	 if (strlen(argv[I]) >= sizeof(Buffer))
	    return _error->Error(_("Option '%s' is too long"),argv[I]);

	 // Skip the leading dash
	 const char *J = argv[I];
	 for (; *J != 0 && *J == '-'; J++);

	 const char *JEnd = strchr(J, '-');
	 if (JEnd != NULL)
	 {
	    strncpy(Buffer,J,JEnd - J);
	    Buffer[JEnd - J] = 0;
	    Argument = Buffer;
	    CertainArg = true;
	 }	 
	 else
	    break;
      }

      // Check for boolean
      Sense = StringToBool(Argument);
      if (Sense >= 0)
      {
	 // Eat the argument	 
	 if (Argument != Buffer)
	 {
	    Opt += strlen(Opt);
	    I += IncI;
	 }	 
	 break;
      }

      if (CertainArg == true)
	 return _error->Error(_("Sense %s is not understood, try true or false."),Argument);
      
      Argument = 0;
   }
      
   // Indeterminate sense depends on the flag
   if (Sense == -1)
   {
      if ((A->Flags & InvBoolean) == InvBoolean)
	 Sense = 0;
      else
	 Sense = 1;
   }
   
   Conf->Set(A->ConfName,Sense);
   return true;
}
									/*}}}*/
// CommandLine::FileSize - Count the number of filenames		/*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned int CommandLine::FileSize() const
{
   unsigned int Count = 0;
   for (const char **I = FileList; I != 0 && *I != 0; I++)
      Count++;
   return Count;
}
									/*}}}*/
// CommandLine::DispatchArg - Do something with the first arg		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool CommandLine::DispatchArg(Dispatch *Map,bool NoMatch)
{
   int I;
   for (I = 0; Map[I].Match != 0; I++)
   {
      if (strcmp(FileList[0],Map[I].Match) == 0)
      {
	 bool Res = Map[I].Handler(*this);
	 if (Res == false && _error->PendingError() == false)
	    _error->Error("Handler silently failed");
	 return Res;
      }
   }
   
   // No matching name
   if (Map[I].Match == 0)
   {
      if (NoMatch == true)
	 _error->Error(_("Invalid operation %s"),FileList[0]);
   }
   
   return false;
}
									/*}}}*/
// CommandLine::SaveInConfig - for output later in a logfile or so	/*{{{*/
// ---------------------------------------------------------------------
/* We save the commandline here to have it around later for e.g. logging.
   It feels a bit like a hack here and isn't bulletproof, but it is better
   than nothing after all. */
void CommandLine::SaveInConfig(unsigned int const &argc, char const * const * const argv)
{
   char cmdline[100 + argc * 50];
   memset(cmdline, 0, sizeof(cmdline));
   unsigned int length = 0;
   bool lastWasOption = false;
   bool closeQuote = false;
   for (unsigned int i = 0; i < argc && length < sizeof(cmdline); ++i, ++length)
   {
      for (unsigned int j = 0; argv[i][j] != '\0' && length < sizeof(cmdline)-1; ++j, ++length)
      {
	 cmdline[length] = argv[i][j];
	 if (lastWasOption == true && argv[i][j] == '=')
	 {
	    // That is possibly an option: Quote it if it includes spaces,
	    // the benefit is that this will eliminate also most false positives
	    const char* c = strchr(&argv[i][j+1], ' ');
	    if (c == NULL) continue;
	    cmdline[++length] = '"';
	    closeQuote = true;
	 }
      }
      if (closeQuote == true)
	 cmdline[length++] = '"';
      // Problem: detects also --hello
      if (cmdline[length-1] == 'o')
	 lastWasOption = true;
      cmdline[length] = ' ';
   }
   cmdline[--length] = '\0';
   _config->Set("CommandLine::AsString", cmdline);
}
									/*}}}*/
CommandLine::Args CommandLine::MakeArgs(char ShortOpt, char const *LongOpt, char const *ConfName, unsigned long Flags)/*{{{*/
{
   /* In theory, this should be a constructor for CommandLine::Args instead,
      but this breaks compatibility as gcc thinks this is a c++11 initializer_list */
   CommandLine::Args arg;
   arg.ShortOpt = ShortOpt;
   arg.LongOpt = LongOpt;
   arg.ConfName = ConfName;
   arg.Flags = Flags;
   return arg;
}
									/*}}}*/
Commit	Line	Data
08e8f724 AL	1	// -- mode: cpp; mode: fold --
08e8f724 AL	2	// Description /{{{/
bac2e715	3	// $Id: cmndline.cc,v 1.15 2003/02/10 01:40:58 doogie Exp $
08e8f724 AL	4	/* ######################################################################
	5
	6	Command Line Class - Sophisticated command line parser
	7
7da2b375 AL	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
08e8f724 AL	11	##################################################################### */
	12	/}}}/
	13	// Include files /{{{/
ea542140 DK	14	#include<config.h>
ea542140 DK	15
472ff00e	16	#include <apt-pkg/configuration.h>
08e8f724 AL	17	#include <apt-pkg/cmndline.h>
08e8f724 AL	18	#include <apt-pkg/error.h>
cdcc6d34	19	#include <apt-pkg/strutl.h>
b2e465d6	20
453b82a3 DK	21	#include <stddef.h>
	22	#include <stdlib.h>
	23	#include <string.h>
	24	#include <string>
	25
ea542140	26	#include <apti18n.h>
08e8f724	27	/}}}/
584e4558	28	using namespace std;
08e8f724 AL	29
	30	// CommandLine::CommandLine - Constructor /{{{/
	31	// ---------------------------------------------------------------------
	32	/* */
	33	CommandLine::CommandLine(Args AList,Configuration Conf) : ArgList(AList),
	34	Conf(Conf), FileList(0)
	35	{
e1b74f61 AL	36	}
	37	/}}}/
	38	// CommandLine::~CommandLine - Destructor /{{{/
	39	// ---------------------------------------------------------------------
	40	/* */
	41	CommandLine::~CommandLine()
	42	{
	43	delete [] FileList;
08e8f724 AL	44	}
08e8f724 AL	45	/}}}/
b9179170 MV	46	// CommandLine::GetCommand - return the first non-option word /{{{/
	47	char const * CommandLine::GetCommand(Dispatch const * const Map,
	48	unsigned int const argc, char const * const * const argv)
	49	{
c4b91cbe DK	50	// if there is a -- on the line there must be the word we search for either
	51	// before it (as -- marks the end of the options) or right after it (as we can't
	52	// decide if the command is actually an option, given that in theory, you could
	53	// have parameters named like commands)
b9179170 MV	54	for (size_t i = 1; i < argc; ++i)
	55	{
	56	if (strcmp(argv[i], "--") != 0)
	57	continue;
c4b91cbe DK	58	// check if command is before --
c4b91cbe DK	59	for (size_t k = 1; k < i; ++k)
b9179170	60	for (size_t j = 0; Map[j].Match != NULL; ++j)
c4b91cbe	61	if (strcmp(argv[k], Map[j].Match) == 0)
b9179170	62	return Map[j].Match;
c4b91cbe DK	63	// see if the next token after -- is the command
	64	++i;
	65	if (i < argc)
b9179170 MV	66	for (size_t j = 0; Map[j].Match != NULL; ++j)
	67	if (strcmp(argv[i], Map[j].Match) == 0)
	68	return Map[j].Match;
c4b91cbe	69	// we found a --, but not a command
b9179170 MV	70	return NULL;
	71	}
	72	// no --, so search for the first word matching a command
	73	// FIXME: How like is it that an option parameter will be also a valid Match ?
	74	for (size_t i = 1; i < argc; ++i)
	75	{
	76	if (*(argv[i]) == '-')
	77	continue;
	78	for (size_t j = 0; Map[j].Match != NULL; ++j)
	79	if (strcmp(argv[i], Map[j].Match) == 0)
	80	return Map[j].Match;
	81	}
	82	return NULL;
	83	}
	84	/}}}/
08e8f724 AL	85	// CommandLine::Parse - Main action member /{{{/
	86	// ---------------------------------------------------------------------
	87	/* */
	88	bool CommandLine::Parse(int argc,const char **argv)
	89	{
e1b74f61	90	delete [] FileList;
08e8f724 AL	91	FileList = new const char *[argc];
	92	const char **Files = FileList;
	93	int I;
	94	for (I = 1; I != argc; I++)
	95	{
	96	const char *Opt = argv[I];
	97
	98	// It is not an option
	99	if (*Opt != '-')
	100	{
	101	*Files++ = Opt;
	102	continue;
	103	}
	104
	105	Opt++;
	106
	107	// Double dash signifies the end of option processing
	108	if (*Opt == '-' && Opt[1] == 0)
343bd48e AL	109	{
343bd48e AL	110	I++;
08e8f724	111	break;
343bd48e	112	}
08e8f724 AL	113
	114	// Single dash is a short option
	115	if (*Opt != '-')
	116	{
	117	// Iterate over each letter
	118	while (*Opt != 0)
	119	{
	120	// Search for the option
	121	Args *A;
	122	for (A = ArgList; A->end() == false && A->ShortOpt != *Opt; A++);
	123	if (A->end() == true)
b2e465d6	124	return _error->Error(_("Command line option '%c' [from %s] is not known."),*Opt,argv[I]);
08e8f724 AL	125
	126	if (HandleOpt(I,argc,argv,Opt,A) == false)
	127	return false;
	128	if (*Opt != 0)
	129	Opt++;
	130	}
	131	continue;
	132	}
	133
	134	Opt++;
	135
	136	// Match up to a = against the list
08e8f724	137	Args *A;
404528bd	138	const char *OptEnd = strchrnul(Opt, '=');
ae2be086 DH	139	for (A = ArgList; A->end() == false &&
	140	(A->LongOpt == 0 \|\| stringcasecmp(Opt,OptEnd,A->LongOpt) != 0);
	141	++A);
08e8f724 AL	142
08e8f724 AL	143	// Failed, look for a word after the first - (no-foo)
0d47bd08	144	bool PreceedMatch = false;
08e8f724 AL	145	if (A->end() == true)
08e8f724 AL	146	{
404528bd DK	147	Opt = (const char*) memchr(Opt, '-', OptEnd - Opt);
404528bd DK	148	if (Opt == NULL)
b2e465d6	149	return _error->Error(_("Command line option %s is not understood"),argv[I]);
08e8f724 AL	150	Opt++;
	151
	152	for (A = ArgList; A->end() == false &&
7a6d9076 DK	153	(A->LongOpt == 0 \|\| stringcasecmp(Opt,OptEnd,A->LongOpt) != 0);
7a6d9076 DK	154	++A);
08e8f724 AL	155
	156	// Failed again..
	157	if (A->end() == true && OptEnd - Opt != 1)
b2e465d6	158	return _error->Error(_("Command line option %s is not understood"),argv[I]);
0d47bd08	159
08e8f724	160	// The option could be a single letter option prefixed by a no-..
08e8f724	161	if (A->end() == true)
0d47bd08 AL	162	{
	163	for (A = ArgList; A->end() == false && A->ShortOpt != *Opt; A++);
	164
	165	if (A->end() == true)
b2e465d6	166	return _error->Error(_("Command line option %s is not understood"),argv[I]);
0d47bd08	167	}
e1b74f61 AL	168
	169	// The option is not boolean
	170	if (A->IsBoolean() == false)
b2e465d6	171	return _error->Error(_("Command line option %s is not boolean"),argv[I]);
0d47bd08	172	PreceedMatch = true;
08e8f724 AL	173	}
	174
	175	// Deal with it.
	176	OptEnd--;
0d47bd08	177	if (HandleOpt(I,argc,argv,OptEnd,A,PreceedMatch) == false)
08e8f724 AL	178	return false;
	179	}
	180
	181	// Copy any remaining file names over
	182	for (; I != argc; I++)
	183	*Files++ = argv[I];
	184	*Files = 0;
2bb25574 DK	185
	186	SaveInConfig(argc, argv);
	187
08e8f724 AL	188	return true;
	189	}
	190	/}}}/
	191	// CommandLine::HandleOpt - Handle a single option including all flags /{{{/
	192	// ---------------------------------------------------------------------
	193	/* This is a helper function for parser, it looks at a given argument
	194	and looks for specific patterns in the string, it gets tokanized
	195	-ruffly- like -[yes\|true\|enable]-(o\|longopt)[=][ ][argument] /
	196	bool CommandLine::HandleOpt(int &I,int argc,const char *argv[],
0d47bd08	197	const char &Opt,Args A,bool PreceedMatch)
08e8f724 AL	198	{
	199	const char *Argument = 0;
	200	bool CertainArg = false;
	201	int IncI = 0;
	202
	203	/* Determine the possible location of an option or 0 if their is
	204	no option */
	205	if (Opt[1] == 0 \|\| (Opt[1] == '=' && Opt[2] == 0))
	206	{
	207	if (I + 1 < argc && argv[I+1][0] != '-')
	208	Argument = argv[I+1];
	209
	210	// Equals was specified but we fell off the end!
	211	if (Opt[1] == '=' && Argument == 0)
b2e465d6	212	return _error->Error(_("Option %s requires an argument."),argv[I]);
08e8f724 AL	213	if (Opt[1] == '=')
	214	CertainArg = true;
	215
	216	IncI = 1;
	217	}
	218	else
	219	{
	220	if (Opt[1] == '=')
	221	{
	222	CertainArg = true;
	223	Argument = Opt + 2;
	224	}
	225	else
	226	Argument = Opt + 1;
	227	}
0d47bd08	228
08e8f724 AL	229	// Option is an argument set
	230	if ((A->Flags & HasArg) == HasArg)
	231	{
	232	if (Argument == 0)
b2e465d6	233	return _error->Error(_("Option %s requires an argument."),argv[I]);
08e8f724 AL	234	Opt += strlen(Opt);
	235	I += IncI;
	236
	237	// Parse a configuration file
	238	if ((A->Flags & ConfigFile) == ConfigFile)
	239	return ReadConfigFile(*Conf,Argument);
e1b74f61	240
0da8987a	241	// Arbitrary item specification
e1b74f61 AL	242	if ((A->Flags & ArbItem) == ArbItem)
e1b74f61 AL	243	{
404528bd DK	244	const char *J = strchr(Argument, '=');
404528bd DK	245	if (J == NULL)
bac2e715	246	return _error->Error(_("Option %s: Configuration item specification must have an =<val>."),argv[I]);
e1b74f61	247
7e798dd7 AL	248	// = is trailing
	249	if (J[1] == 0)
	250	{
	251	if (I+1 >= argc)
bac2e715	252	return _error->Error(_("Option %s: Configuration item specification must have an =<val>."),argv[I]);
7e798dd7 AL	253	Conf->Set(string(Argument,J-Argument),string(argv[I++ +1]));
	254	}
	255	else
	256	Conf->Set(string(Argument,J-Argument),string(J+1));
e1b74f61 AL	257
	258	return true;
	259	}
08e8f724	260
404528bd	261	const char *I = strchrnul(A->ConfName, ' ');
7f25bdff AL	262	if (*I == ' ')
	263	Conf->Set(string(A->ConfName,0,I-A->ConfName),string(I+1) + Argument);
	264	else
	265	Conf->Set(A->ConfName,string(I) + Argument);
	266
08e8f724 AL	267	return true;
	268	}
	269
	270	// Option is an integer level
	271	if ((A->Flags & IntLevel) == IntLevel)
	272	{
	273	// There might be an argument
	274	if (Argument != 0)
	275	{
	276	char *EndPtr;
	277	unsigned long Value = strtol(Argument,&EndPtr,10);
	278
	279	// Conversion failed and the argument was specified with an =s
	280	if (EndPtr == Argument && CertainArg == true)
b2e465d6	281	return _error->Error(_("Option %s requires an integer argument, not '%s'"),argv[I],Argument);
08e8f724 AL	282
08e8f724 AL	283	// Conversion was ok, set the value and return
9435cc9b	284	if (EndPtr != 0 && EndPtr != Argument && *EndPtr == 0)
08e8f724 AL	285	{
	286	Conf->Set(A->ConfName,Value);
	287	Opt += strlen(Opt);
	288	I += IncI;
	289	return true;
	290	}
	291	}
	292
	293	// Increase the level
	294	Conf->Set(A->ConfName,Conf->FindI(A->ConfName)+1);
	295	return true;
	296	}
	297
	298	// Option is a boolean
	299	int Sense = -1; // -1 is unspecified, 0 is yes 1 is no
	300
	301	// Look for an argument.
	302	while (1)
	303	{
1e3f4083	304	// Look at preceding text
08e8f724 AL	305	char Buffer[300];
	306	if (Argument == 0)
	307	{
0d47bd08 AL	308	if (PreceedMatch == false)
	309	break;
	310
08e8f724	311	if (strlen(argv[I]) >= sizeof(Buffer))
b2e465d6	312	return _error->Error(_("Option '%s' is too long"),argv[I]);
0d47bd08 AL	313
0d47bd08 AL	314	// Skip the leading dash
08e8f724 AL	315	const char *J = argv[I];
08e8f724 AL	316	for (; J != 0 && J == '-'; J++);
404528bd DK	317
	318	const char *JEnd = strchr(J, '-');
	319	if (JEnd != NULL)
08e8f724 AL	320	{
	321	strncpy(Buffer,J,JEnd - J);
	322	Buffer[JEnd - J] = 0;
	323	Argument = Buffer;
	324	CertainArg = true;
	325	}
	326	else
	327	break;
	328	}
	329
3b5421b4 AL	330	// Check for boolean
	331	Sense = StringToBool(Argument);
	332	if (Sense >= 0)
08e8f724	333	{
08e8f724 AL	334	// Eat the argument
	335	if (Argument != Buffer)
	336	{
	337	Opt += strlen(Opt);
	338	I += IncI;
	339	}
	340	break;
	341	}
	342
08e8f724	343	if (CertainArg == true)
b2e465d6	344	return _error->Error(_("Sense %s is not understood, try true or false."),Argument);
08e8f724 AL	345
	346	Argument = 0;
	347	}
	348
	349	// Indeterminate sense depends on the flag
	350	if (Sense == -1)
	351	{
	352	if ((A->Flags & InvBoolean) == InvBoolean)
	353	Sense = 0;
	354	else
	355	Sense = 1;
	356	}
	357
	358	Conf->Set(A->ConfName,Sense);
	359	return true;
	360	}
	361	/}}}/
bc4af0b9	362	// CommandLine::FileSize - Count the number of filenames /{{{/
e1b74f61 AL	363	// ---------------------------------------------------------------------
	364	/* */
	365	unsigned int CommandLine::FileSize() const
	366	{
	367	unsigned int Count = 0;
	368	for (const char *I = FileList; I != 0 && I != 0; I++)
	369	Count++;
	370	return Count;
	371	}
	372	/}}}/
bc4af0b9 AL	373	// CommandLine::DispatchArg - Do something with the first arg /{{{/
	374	// ---------------------------------------------------------------------
	375	/* */
b0b4efb9	376	bool CommandLine::DispatchArg(Dispatch *Map,bool NoMatch)
bc4af0b9 AL	377	{
	378	int I;
	379	for (I = 0; Map[I].Match != 0; I++)
	380	{
	381	if (strcmp(FileList[0],Map[I].Match) == 0)
	382	{
	383	bool Res = Map[I].Handler(*this);
	384	if (Res == false && _error->PendingError() == false)
	385	_error->Error("Handler silently failed");
	386	return Res;
	387	}
	388	}
	389
	390	// No matching name
	391	if (Map[I].Match == 0)
b0b4efb9 AL	392	{
b0b4efb9 AL	393	if (NoMatch == true)
b2e465d6	394	_error->Error(_("Invalid operation %s"),FileList[0]);
b0b4efb9 AL	395	}
b0b4efb9 AL	396
bc4af0b9 AL	397	return false;
	398	}
	399	/}}}/
2bb25574 DK	400	// CommandLine::SaveInConfig - for output later in a logfile or so /{{{/
	401	// ---------------------------------------------------------------------
	402	/* We save the commandline here to have it around later for e.g. logging.
	403	It feels a bit like a hack here and isn't bulletproof, but it is better
	404	than nothing after all. */
	405	void CommandLine::SaveInConfig(unsigned int const &argc, char const * const * const argv)
	406	{
093e9f5d	407	char cmdline[100 + argc * 50];
70e0c168	408	memset(cmdline, 0, sizeof(cmdline));
2bb25574 DK	409	unsigned int length = 0;
	410	bool lastWasOption = false;
	411	bool closeQuote = false;
093e9f5d	412	for (unsigned int i = 0; i < argc && length < sizeof(cmdline); ++i, ++length)
2bb25574 DK	413	{
	414	for (unsigned int j = 0; argv[i][j] != '\0' && length < sizeof(cmdline)-1; ++j, ++length)
	415	{
	416	cmdline[length] = argv[i][j];
	417	if (lastWasOption == true && argv[i][j] == '=')
	418	{
	419	// That is possibly an option: Quote it if it includes spaces,
	420	// the benefit is that this will eliminate also most false positives
404528bd DK	421	const char* c = strchr(&argv[i][j+1], ' ');
404528bd DK	422	if (c == NULL) continue;
2bb25574 DK	423	cmdline[++length] = '"';
	424	closeQuote = true;
	425	}
	426	}
	427	if (closeQuote == true)
	428	cmdline[length++] = '"';
	429	// Problem: detects also --hello
	430	if (cmdline[length-1] == 'o')
	431	lastWasOption = true;
	432	cmdline[length] = ' ';
	433	}
	434	cmdline[--length] = '\0';
	435	_config->Set("CommandLine::AsString", cmdline);
	436	}
	437	/}}}/
b9179170 MV	438	CommandLine::Args CommandLine::MakeArgs(char ShortOpt, char const LongOpt, char const ConfName, unsigned long Flags)/{{{/
	439	{
	440	/* In theory, this should be a constructor for CommandLine::Args instead,
	441	but this breaks compatibility as gcc thinks this is a c++11 initializer_list */
	442	CommandLine::Args arg;
	443	arg.ShortOpt = ShortOpt;
	444	arg.LongOpt = LongOpt;
	445	arg.ConfName = ConfName;
	446	arg.Flags = Flags;
	447	return arg;
	448	}
	449	/}}}/