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