]> git.decadent.org.uk Git - dak.git/blob - tools/dsync-0.0/libdsync/contrib/configuration.cc
Fix typo.
[dak.git] / tools / dsync-0.0 / libdsync / contrib / configuration.cc
1 // -*- mode: cpp; mode: fold -*-
2 // Description                                                          /*{{{*/
3 // $Id: configuration.cc,v 1.5 1999/11/17 05:59:29 jgg Exp $
4 /* ######################################################################
5
6    Configuration Class
7    
8    This class provides a configuration file and command line parser
9    for a tree-oriented configuration environment. All runtime configuration
10    is stored in here.
11    
12    ##################################################################### */
13                                                                         /*}}}*/
14 // Include files                                                        /*{{{*/
15 #ifdef __GNUG__
16 #pragma implementation "dsync/configuration.h"
17 #endif
18 #include <dsync/configuration.h>
19 #include <dsync/error.h>
20 #include <dsync/strutl.h>
21
22 #include <stdio.h>
23 #include <fstream>
24 #include <iostream>
25 using namespace std;
26                                                                         /*}}}*/
27
28 Configuration *_config = new Configuration;
29
30 // Configuration::Configuration - Constructor                           /*{{{*/
31 // ---------------------------------------------------------------------
32 /* */
33 Configuration::Configuration()
34 {
35    Root = new Item;
36 }
37                                                                         /*}}}*/
38 // Configuration::Lookup - Lookup a single item                         /*{{{*/
39 // ---------------------------------------------------------------------
40 /* This will lookup a single item by name below another item. It is a 
41    helper function for the main lookup function */
42 Configuration::Item *Configuration::Lookup(Item *Head,const char *S,
43                                            unsigned long Len,bool Create)
44 {
45    int Res = 1;
46    Item *I = Head->Child;
47    Item **Last = &Head->Child;
48    
49    // Empty strings match nothing. They are used for lists.
50    if (Len != 0)
51    {
52       for (; I != 0; Last = &I->Next, I = I->Next)
53          if ((Res = stringcasecmp(I->Tag.c_str(), I->Tag.c_str() + strlen(I->Tag.c_str()),S,S + Len)) == 0)
54             break;
55    }
56    else
57       for (; I != 0; Last = &I->Next, I = I->Next);
58       
59    if (Res == 0)
60       return I;
61    if (Create == false)
62       return 0;
63    
64    I = new Item;
65    I->Tag = string(S,Len);
66    I->Next = *Last;
67    I->Parent = Head;
68    *Last = I;
69    return I;
70 }
71                                                                         /*}}}*/
72 // Configuration::Lookup - Lookup a fully scoped item                   /*{{{*/
73 // ---------------------------------------------------------------------
74 /* This performs a fully scoped lookup of a given name, possibly creating
75    new items */
76 Configuration::Item *Configuration::Lookup(const char *Name,bool Create)
77 {
78    if (Name == 0)
79       return Root->Child;
80    
81    const char *Start = Name;
82    const char *End = Start + strlen(Name);
83    const char *TagEnd = Name;
84    Item *Itm = Root;
85    for (; End - TagEnd >= 2; TagEnd++)
86    {
87       if (TagEnd[0] == ':' && TagEnd[1] == ':')
88       {
89          Itm = Lookup(Itm,Start,TagEnd - Start,Create);
90          if (Itm == 0)
91             return 0;
92          TagEnd = Start = TagEnd + 2;    
93       }
94    }   
95
96    // This must be a trailing ::, we create unique items in a list
97    if (End - Start == 0)
98    {
99       if (Create == false)
100          return 0;
101    }
102    
103    Itm = Lookup(Itm,Start,End - Start,Create);
104    return Itm;
105 }
106                                                                         /*}}}*/
107 // Configuration::Find - Find a value                                   /*{{{*/
108 // ---------------------------------------------------------------------
109 /* */
110 string Configuration::Find(const char *Name,const char *Default)
111 {
112    Item *Itm = Lookup(Name,false);
113    if (Itm == 0 || Itm->Value.empty() == true)
114    {
115       if (Default == 0)
116          return string();
117       else
118          return Default;
119    }
120    
121    return Itm->Value;
122 }
123                                                                         /*}}}*/
124 // Configuration::FindFile - Find a Filename                            /*{{{*/
125 // ---------------------------------------------------------------------
126 /* Directories are stored as the base dir in the Parent node and the
127    sub directory in sub nodes with the final node being the end filename
128  */
129 string Configuration::FindFile(const char *Name,const char *Default)
130 {
131    Item *Itm = Lookup(Name,false);
132    if (Itm == 0 || Itm->Value.empty() == true)
133    {
134       if (Default == 0)
135          return string();
136       else
137          return Default;
138    }
139    
140    // Absolute path
141    if (Itm->Value[0] == '/' || Itm->Parent == 0)
142       return Itm->Value;
143    
144    // ./ is also considered absolute as is anything with ~ in it
145    if (Itm->Value[0] != 0 && 
146        ((Itm->Value[0] == '.' && Itm->Value[1] == '/') ||
147         (Itm->Value[0] == '~' && Itm->Value[1] == '/')))
148       return Itm->Value;
149    
150    if (Itm->Parent->Value.end()[-1] == '/')
151       return Itm->Parent->Value + Itm->Value;
152    else
153       return Itm->Parent->Value + '/' + Itm->Value;
154 }
155                                                                         /*}}}*/
156 // Configuration::FindDir - Find a directory name                       /*{{{*/
157 // ---------------------------------------------------------------------
158 /* This is like findfile execept the result is terminated in a / */
159 string Configuration::FindDir(const char *Name,const char *Default)
160 {
161    string Res = FindFile(Name,Default);
162    if (Res.end()[-1] != '/')
163       return Res + '/';
164    return Res;
165 }
166                                                                         /*}}}*/
167 // Configuration::FindI - Find an integer value                         /*{{{*/
168 // ---------------------------------------------------------------------
169 /* */
170 int Configuration::FindI(const char *Name,int Default)
171 {
172    Item *Itm = Lookup(Name,false);
173    if (Itm == 0 || Itm->Value.empty() == true)
174       return Default;
175    
176    char *End;
177    int Res = strtol(Itm->Value.c_str(),&End,0);
178    if (End == Itm->Value.c_str())
179       return Default;
180    
181    return Res;
182 }
183                                                                         /*}}}*/
184 // Configuration::FindB - Find a boolean type                           /*{{{*/
185 // ---------------------------------------------------------------------
186 /* */
187 bool Configuration::FindB(const char *Name,bool Default)
188 {
189    Item *Itm = Lookup(Name,false);
190    if (Itm == 0 || Itm->Value.empty() == true)
191       return Default;
192    
193    return StringToBool(Itm->Value,Default);
194 }
195                                                                         /*}}}*/
196 // Configuration::Set - Set a value                                     /*{{{*/
197 // ---------------------------------------------------------------------
198 /* */
199 void Configuration::Set(const char *Name,string Value)
200 {
201    Item *Itm = Lookup(Name,true);
202    if (Itm == 0)
203       return;
204    Itm->Value = Value;
205 }
206                                                                         /*}}}*/
207 // Configuration::Set - Set an integer value                            /*{{{*/
208 // ---------------------------------------------------------------------
209 /* */
210 void Configuration::Set(const char *Name,int Value)
211 {
212    Item *Itm = Lookup(Name,true);
213    if (Itm == 0)
214       return;
215    char S[300];
216    snprintf(S,sizeof(S),"%i",Value);
217    Itm->Value = S;
218 }
219                                                                         /*}}}*/
220 // Configuration::Exists - Returns true if the Name exists              /*{{{*/
221 // ---------------------------------------------------------------------
222 /* */
223 bool Configuration::Exists(const char *Name)
224 {
225    Item *Itm = Lookup(Name,false);
226    if (Itm == 0)
227       return false;
228    return true;
229 }
230                                                                         /*}}}*/
231 // Configuration::Dump - Dump the config                                /*{{{*/
232 // ---------------------------------------------------------------------
233 /* Dump the entire configuration space */
234 void Configuration::Dump()
235 {
236    /* Write out all of the configuration directives by walking the 
237       configuration tree */
238    const Configuration::Item *Top = _config->Tree(0);
239    for (; Top != 0;)
240    {
241       clog << Top->FullTag() << " \"" << Top->Value << "\";" << endl;
242       
243       if (Top->Child != 0)
244       {
245          Top = Top->Child;
246          continue;
247       }
248       
249       while (Top != 0 && Top->Next == 0)
250          Top = Top->Parent;
251       if (Top != 0)
252          Top = Top->Next;
253    }   
254 }
255                                                                         /*}}}*/
256
257 // Configuration::Item::FullTag - Return the fully scoped tag           /*{{{*/
258 // ---------------------------------------------------------------------
259 /* */
260 string Configuration::Item::FullTag() const
261 {
262    if (Parent == 0 || Parent->Parent == 0)
263       return Tag;
264    return Parent->FullTag() + "::" + Tag;
265 }
266                                                                         /*}}}*/
267
268 // ReadConfigFile - Read a configuration file                           /*{{{*/
269 // ---------------------------------------------------------------------
270 /* The configuration format is very much like the named.conf format
271    used in bind8, in fact this routine can parse most named.conf files. */
272 bool ReadConfigFile(Configuration &Conf,string FName)
273 {
274    // Open the stream for reading
275    ifstream F(FName.c_str(),ios::in);
276    if (!F != 0)
277       return _error->Errno("ifstream::ifstream","Opening configuration file %s",FName.c_str());
278    
279    char Buffer[300];
280    string LineBuffer;
281    string Stack[100];
282    unsigned int StackPos = 0;
283    
284    // Parser state
285    string ParentTag;
286    
287    int CurLine = 0;
288    bool InComment = false;
289    while (F.eof() == false)
290    {
291       F.getline(Buffer,sizeof(Buffer));
292       CurLine++;
293       _strtabexpand(Buffer,sizeof(Buffer));
294       _strstrip(Buffer);
295
296       // Multi line comment
297       if (InComment == true)
298       {
299          for (const char *I = Buffer; *I != 0; I++)
300          {
301             if (*I == '*' && I[1] == '/')
302             {
303                memmove(Buffer,I+2,strlen(I+2) + 1);
304                InComment = false;
305                break;
306             }       
307          }
308          if (InComment == true)
309             continue;
310       }
311       
312       // Discard single line comments
313       bool InQuote = false;
314       for (char *I = Buffer; *I != 0; I++)
315       {
316          if (*I == '"')
317             InQuote = !InQuote;
318          if (InQuote == true)
319             continue;
320          
321          if (*I == '/' && I[1] == '/')
322          {
323             *I = 0;
324             break;
325          }
326       }
327       
328       // Look for multi line comments
329       for (char *I = Buffer; *I != 0; I++)
330       {
331          if (*I == '"')
332             InQuote = !InQuote;
333          if (InQuote == true)
334             continue;
335          
336          if (*I == '/' && I[1] == '*')
337          {
338             InComment = true;
339             for (char *J = Buffer; *J != 0; J++)
340             {
341                if (*J == '*' && J[1] == '/')
342                {
343                   memmove(I,J+2,strlen(J+2) + 1);
344                   InComment = false;
345                   break;
346                }               
347             }
348             
349             if (InComment == true)
350             {
351                *I = 0;
352                break;
353             }       
354          }
355       }
356       
357       // Blank
358       if (Buffer[0] == 0)
359          continue;
360       
361       // We now have a valid line fragment
362       for (char *I = Buffer; *I != 0;)
363       {
364          if (*I == '{' || *I == ';' || *I == '}')
365          {
366             // Put the last fragement into the buffer
367             char *Start = Buffer;
368             char *Stop = I;
369             for (; Start != I && isspace(*Start) != 0; Start++);
370             for (; Stop != Start && isspace(Stop[-1]) != 0; Stop--);
371             if (LineBuffer.empty() == false && Stop - Start != 0)
372                LineBuffer += ' ';
373             LineBuffer += string(Start,Stop - Start);
374             
375             // Remove the fragment
376             char TermChar = *I;
377             memmove(Buffer,I + 1,strlen(I + 1) + 1);
378             I = Buffer;
379
380             // Move up a tag
381             if (TermChar == '}')
382             {
383                if (StackPos == 0)
384                   ParentTag = string();
385                else
386                   ParentTag = Stack[--StackPos];
387             }
388             
389             // Syntax Error
390             if (TermChar == '{' && LineBuffer.empty() == true)
391                return _error->Error("Syntax error %s:%u: Block starts with no name.",FName.c_str(),CurLine);
392             
393             if (LineBuffer.empty() == true)
394                continue;
395
396             // Parse off the tag
397             string Tag;
398             const char *Pos = LineBuffer.c_str();
399             if (ParseQuoteWord(Pos,Tag) == false)
400                return _error->Error("Syntax error %s:%u: Malformed Tag",FName.c_str(),CurLine);     
401             
402             // Go down a level
403             if (TermChar == '{')
404             {
405                if (StackPos <= 100)
406                   Stack[StackPos++] = ParentTag;
407                if (ParentTag.empty() == true)
408                   ParentTag = Tag;
409                else
410                   ParentTag += string("::") + Tag;
411                Tag = string();
412             }
413
414             // Parse off the word
415             string Word;
416             if (ParseCWord(Pos,Word) == false)
417             {
418                if (TermChar != '{')
419                {
420                   Word = Tag;
421                   Tag = "";
422                }               
423             }
424             
425             // Generate the item name
426             string Item;
427             if (ParentTag.empty() == true)
428                Item = Tag;
429             else
430             {
431                if (TermChar != '{' || Tag.empty() == false)
432                   Item = ParentTag + "::" + Tag;
433                else
434                   Item = ParentTag;
435             }
436             
437             // Set the item in the configuration class
438             Conf.Set(Item,Word);
439                             
440             // Empty the buffer
441             LineBuffer = string();
442          }
443          else
444             I++;
445       }
446
447       // Store the fragment
448       const char *Stripd = _strstrip(Buffer);
449       if (*Stripd != 0 && LineBuffer.empty() == false)
450          LineBuffer += " ";
451       LineBuffer += Stripd;
452    }
453    
454    return true;
455 }
456                                                                         /*}}}*/