|
179
|
1 /* |
|
|
2 * Parser.h -- config file parser |
|
|
3 * |
|
|
4 * Copyright (c) 2011, 2012, 2013 David Demelier <markand@malikania.fr> |
|
|
5 * |
|
|
6 * Permission to use, copy, modify, and/or distribute this software for any |
|
|
7 * purpose with or without fee is hereby granted, provided that the above |
|
|
8 * copyright notice and this permission notice appear in all copies. |
|
|
9 * |
|
|
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
|
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
|
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
|
|
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
|
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|
|
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|
|
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
|
17 */ |
|
|
18 |
|
|
19 #include <iostream> |
|
|
20 #include <fstream> |
|
|
21 |
|
|
22 #include "Parser.h" |
|
|
23 |
|
|
24 /* -------------------------------------------------------- |
|
|
25 * Option public members |
|
|
26 * -------------------------------------------------------- */ |
|
|
27 |
|
|
28 bool operator==(const Option &o1, const Option &o2) |
|
|
29 { |
|
|
30 return o1.m_key == o2.m_key && |
|
|
31 o1.m_value == o2.m_value; |
|
|
32 } |
|
|
33 |
|
|
34 /* -------------------------------------------------------- |
|
|
35 * Section public members |
|
|
36 * -------------------------------------------------------- */ |
|
|
37 |
|
|
38 Section::Section() |
|
180
|
39 : m_allowed(true) |
|
179
|
40 { |
|
|
41 } |
|
|
42 |
|
180
|
43 const std::string &Section::getName() const |
|
179
|
44 { |
|
180
|
45 return m_name; |
|
179
|
46 } |
|
|
47 |
|
|
48 const std::string Section::findOption(const std::string &name) const |
|
|
49 { |
|
|
50 std::string ret; |
|
|
51 |
|
|
52 for (const Option &o : m_options) |
|
180
|
53 if (o.m_key == name) |
|
|
54 { |
|
179
|
55 ret = o.m_value; |
|
|
56 break; |
|
|
57 } |
|
|
58 |
|
|
59 return ret; |
|
|
60 } |
|
|
61 |
|
180
|
62 template <> |
|
|
63 bool Section::getValue(const std::string &name) const |
|
179
|
64 { |
|
|
65 bool result = false; |
|
|
66 |
|
180
|
67 if (hasOption(name)) |
|
|
68 { |
|
179
|
69 std::string value = findOption(name); |
|
|
70 |
|
|
71 if (value == "yes" || value == "true"|| value == "1") |
|
|
72 result = true; |
|
|
73 else if (value == "no" || value == "false" || value == "0") |
|
|
74 result = false; |
|
|
75 } |
|
|
76 |
|
|
77 return result; |
|
|
78 } |
|
|
79 |
|
180
|
80 template <> |
|
|
81 int Section::getValue(const std::string &name) const |
|
179
|
82 { |
|
|
83 int result = -1; |
|
|
84 |
|
180
|
85 if (hasOption(name)) |
|
179
|
86 result = atoi(findOption(name).c_str()); |
|
|
87 |
|
|
88 return result; |
|
|
89 } |
|
|
90 |
|
180
|
91 template <> |
|
|
92 std::string Section::getValue(const std::string &name) const |
|
179
|
93 { |
|
|
94 std::string result; |
|
|
95 |
|
|
96 if (hasOption(name)) |
|
|
97 result = findOption(name); |
|
|
98 |
|
|
99 return result; |
|
|
100 } |
|
|
101 |
|
180
|
102 const std::vector<Option> &Section::getOptions() const |
|
179
|
103 { |
|
|
104 return m_options; |
|
|
105 } |
|
|
106 |
|
|
107 bool Section::hasOption(const std::string &name) const |
|
|
108 { |
|
|
109 for (const Option &o : m_options) |
|
|
110 if (o.m_key == name) |
|
|
111 return true; |
|
|
112 |
|
|
113 return false; |
|
|
114 } |
|
|
115 |
|
|
116 bool operator==(const Section &s1, const Section &s2) |
|
|
117 { |
|
|
118 if (s1.m_name != s2.m_name) |
|
|
119 return false; |
|
|
120 |
|
|
121 return s1.m_options == s2.m_options; |
|
|
122 } |
|
|
123 |
|
|
124 /* -------------------------------------------------------- |
|
|
125 * Parser private members |
|
|
126 * -------------------------------------------------------- */ |
|
|
127 |
|
|
128 void Parser::addSection(const std::string &name) |
|
|
129 { |
|
|
130 Section section; |
|
|
131 |
|
|
132 section.m_name = name; |
|
|
133 section.m_allowed = true; |
|
|
134 |
|
|
135 m_sections.push_back(section); |
|
|
136 } |
|
|
137 |
|
|
138 void Parser::addOption(const std::string &key, const std::string &value) |
|
|
139 { |
|
|
140 Option option; |
|
|
141 Section ¤t = m_sections.back(); |
|
|
142 |
|
|
143 option.m_key = key; |
|
|
144 option.m_value = value; |
|
|
145 |
|
|
146 current.m_options.push_back(option); |
|
|
147 } |
|
|
148 |
|
|
149 void Parser::readSection(int lineno, const std::string &line) |
|
|
150 { |
|
|
151 size_t end; |
|
|
152 |
|
180
|
153 if ((end = line.find_first_of(']')) != std::string::npos) |
|
|
154 { |
|
|
155 if (end > 1) |
|
|
156 { |
|
179
|
157 std::string name = line.substr(1, end - 1); |
|
|
158 |
|
|
159 /* |
|
|
160 * Check if we can add a section, if redefinition is |
|
|
161 * disabled, we must disable the previous section so the |
|
|
162 * further read options should not be enabled until |
|
|
163 * a correct section is found again. |
|
|
164 */ |
|
180
|
165 if (hasSection(name) && (m_tuning & DisableRedefinition)) |
|
|
166 { |
|
179
|
167 if (!(m_tuning & DisableVerbosity)) |
|
|
168 log(lineno, name, "redefinition not allowed"); |
|
|
169 m_sections.back().m_allowed = false; |
|
180
|
170 } |
|
|
171 else |
|
179
|
172 addSection(name); |
|
180
|
173 } |
|
|
174 else if (!(m_tuning & DisableVerbosity)) |
|
|
175 { |
|
179
|
176 /* |
|
|
177 * Do not add options at this step because it will |
|
|
178 * corrupt the previous one. |
|
|
179 */ |
|
|
180 m_sections.back().m_allowed = false; |
|
|
181 log(lineno, "", "empty section name"); |
|
|
182 } |
|
|
183 } |
|
|
184 } |
|
|
185 |
|
|
186 void Parser::readOption(int lineno, const std::string &line) |
|
|
187 { |
|
|
188 size_t epos; |
|
|
189 std::string key, value; |
|
|
190 Section ¤t = m_sections.back(); |
|
|
191 |
|
|
192 // Error on last section? |
|
180
|
193 if (!current.m_allowed) |
|
|
194 { |
|
179
|
195 /* |
|
|
196 * If it is the root section, this has been probably set by |
|
|
197 * DisableRootSection flag, otherwise an error has occured |
|
|
198 * so no need to log. |
|
|
199 */ |
|
|
200 if (current.m_name == "" && !(m_tuning == DisableVerbosity)) |
|
|
201 log(lineno, "", "option not allowed in that scope"); |
|
|
202 |
|
|
203 return; |
|
|
204 } |
|
|
205 |
|
180
|
206 if ((epos = line.find_first_of('=')) == std::string::npos) |
|
|
207 { |
|
179
|
208 if (!(m_tuning & DisableVerbosity)) |
|
|
209 log(lineno, current.m_name, "missing `=' keyword"); |
|
|
210 return; |
|
|
211 } |
|
|
212 |
|
180
|
213 if (epos > 0) |
|
|
214 { |
|
179
|
215 size_t i, begin, last; |
|
|
216 char c; |
|
|
217 |
|
|
218 key = line.substr(0, epos - 1); |
|
|
219 value = line.substr(epos + 1); |
|
|
220 |
|
|
221 // clean option key |
|
|
222 for (i = 0; !isspace(key[i]) && i < key.length(); ++i) |
|
|
223 continue; |
|
|
224 key = key.substr(0, i); |
|
|
225 |
|
|
226 // clean option value |
|
|
227 for (begin = 0; isspace(value[begin]) && begin < value.length(); ++begin) |
|
|
228 continue; |
|
|
229 value = value.substr(begin); |
|
|
230 |
|
|
231 c = value[0]; |
|
|
232 begin = 0; |
|
180
|
233 if (c == '\'' || c == '"') |
|
|
234 { |
|
179
|
235 for (last = begin = 1; value[last] != c && last < value.length(); ++last) |
|
|
236 continue; |
|
|
237 if (value[last] != c && !(m_tuning & DisableVerbosity)) |
|
|
238 if (!(m_tuning & DisableVerbosity)) |
|
|
239 log(lineno, current.m_name, "undisclosed std::string"); |
|
180
|
240 } |
|
|
241 else |
|
|
242 { |
|
179
|
243 for (last = begin; !isspace(value[last]) && last < value.length(); ++last) |
|
|
244 continue; |
|
|
245 } |
|
|
246 |
|
|
247 if (last - begin > 0) |
|
|
248 value = value.substr(begin, last - begin); |
|
|
249 else |
|
|
250 value.clear(); |
|
|
251 |
|
|
252 // Add the option if the key is not empty |
|
|
253 if (key.length() > 0) |
|
|
254 addOption(key, value); |
|
|
255 } |
|
|
256 } |
|
|
257 |
|
|
258 void Parser::readLine(int lineno, const std::string &line) |
|
|
259 { |
|
|
260 size_t i; |
|
|
261 std::string buffer; |
|
|
262 |
|
|
263 // Skip default spaces |
|
|
264 for (i = 0; isspace(line[i]) && i < line.length(); ++i) |
|
|
265 continue; |
|
|
266 |
|
|
267 buffer = line.substr(i); |
|
180
|
268 if (buffer.length() > 0) |
|
|
269 { |
|
|
270 if (buffer[0] != m_commentChar) |
|
|
271 { |
|
179
|
272 if (buffer[0] == '[') |
|
|
273 readSection(lineno, buffer); |
|
|
274 else |
|
|
275 readOption(lineno, buffer); |
|
|
276 } |
|
|
277 } |
|
|
278 } |
|
|
279 |
|
|
280 /* -------------------------------------------------------- |
|
|
281 * Parser public methods |
|
|
282 * -------------------------------------------------------- */ |
|
|
283 |
|
|
284 const char Parser::DEFAULT_COMMENT_CHAR = '#'; |
|
|
285 |
|
180
|
286 Parser::Parser() |
|
|
287 { |
|
|
288 } |
|
|
289 |
|
179
|
290 Parser::Parser(const std::string &path, int tuning, char commentToken) |
|
180
|
291 : m_path(path) |
|
|
292 , m_tuning(tuning) |
|
|
293 , m_commentChar(commentToken) |
|
179
|
294 { |
|
|
295 Section root; |
|
|
296 |
|
|
297 // Add a default root section |
|
|
298 root.m_name = ""; |
|
|
299 root.m_allowed = (tuning & DisableRootSection) ? false : true; |
|
|
300 |
|
|
301 m_sections.push_back(root); |
|
|
302 } |
|
|
303 |
|
|
304 Parser::~Parser() |
|
|
305 { |
|
|
306 } |
|
|
307 |
|
|
308 bool Parser::open() |
|
|
309 { |
|
|
310 std::ifstream file; |
|
|
311 std::string line; |
|
|
312 int lineno = 1; |
|
|
313 |
|
|
314 file.open(m_path.c_str()); |
|
180
|
315 if (!file.is_open()) |
|
|
316 { |
|
179
|
317 m_error = "could not open file " + m_path; // XXX: add a real error |
|
|
318 return false; |
|
|
319 } |
|
|
320 |
|
|
321 // Avoid use of C getline |
|
180
|
322 while (std::getline(file, line)) |
|
179
|
323 readLine(lineno++, line); |
|
|
324 |
|
|
325 file.close(); |
|
|
326 |
|
|
327 return true; |
|
|
328 } |
|
|
329 |
|
180
|
330 const std::string &Parser::getError() const |
|
179
|
331 { |
|
|
332 return m_error; |
|
|
333 } |
|
|
334 |
|
180
|
335 const std::vector<Section> &Parser::getSections() const |
|
179
|
336 { |
|
|
337 return m_sections; |
|
|
338 } |
|
|
339 |
|
180
|
340 void Parser::findSections(const std::string &name, FindFunc func) const |
|
179
|
341 { |
|
180
|
342 for (const Section &s : m_sections) |
|
|
343 if (s.m_name == name) |
|
|
344 func(s); |
|
179
|
345 } |
|
|
346 |
|
|
347 bool Parser::hasSection(const std::string &name) const |
|
|
348 { |
|
|
349 for (const Section &s : m_sections) |
|
|
350 if (s.m_name == name) |
|
|
351 return true; |
|
|
352 |
|
|
353 return false; |
|
|
354 } |
|
|
355 |
|
180
|
356 const Section &Parser::getSection(const std::string &name) const |
|
179
|
357 { |
|
|
358 for (const Section &s : m_sections) |
|
|
359 if (s.m_name == name) |
|
180
|
360 return s; |
|
179
|
361 |
|
180
|
362 throw NotFoundException(name); |
|
179
|
363 } |
|
|
364 |
|
180
|
365 const Section &Parser::requireSection(const std::string &name) const |
|
179
|
366 { |
|
|
367 if (!hasSection(name)) |
|
|
368 throw NotFoundException(name); |
|
|
369 |
|
|
370 return getSection(name); |
|
|
371 } |
|
|
372 |
|
|
373 void Parser::log(int number, const std::string &, const std::string &message) |
|
|
374 { |
|
|
375 std::cout << "line " << number << ": " << message << std::endl; |
|
|
376 } |
|
|
377 |
|
|
378 void Parser::dump() |
|
|
379 { |
|
180
|
380 for (auto s : m_sections) |
|
|
381 { |
|
179
|
382 dumpSection(s); |
|
180
|
383 |
|
179
|
384 for (auto o : s.m_options) |
|
|
385 dumpOption(o); |
|
|
386 } |
|
|
387 } |
|
|
388 |
|
|
389 void Parser::dumpSection(const Section §ion) |
|
|
390 { |
|
|
391 std::cout << "Section " << section.m_name << std::endl; |
|
|
392 } |
|
|
393 |
|
|
394 void Parser::dumpOption(const Option &option) |
|
|
395 { |
|
|
396 std::cout << " Option " << option.m_key << " = " << option.m_value << std::endl; |
|
|
397 } |
