2057
|
1 /* Audacious
|
|
2 * Copyright (c) 2005-2007 Audacious team
|
|
3 *
|
|
4 * BMP
|
|
5 * Copyright (c) 2003-2005 BMP team
|
|
6 *
|
|
7 * This program is free software; you can redistribute it and/or modify
|
0
|
8 * it under the terms of the GNU General Public License as published by
|
|
9 * the Free Software Foundation; either version 2 of the License, or
|
|
10 * (at your option) any later version.
|
|
11 *
|
|
12 * This program is distributed in the hope that it will be useful,
|
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
15 * GNU General Public License for more details.
|
|
16 *
|
|
17 * You should have received a copy of the GNU General Public License
|
|
18 * along with this program; if not, write to the Free Software
|
1459
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
0
|
20 */
|
|
21
|
|
22 #include "rcfile.h"
|
|
23
|
|
24 #include <stdio.h>
|
|
25 #include <string.h>
|
|
26 #include <stdlib.h>
|
|
27 #include <locale.h>
|
|
28
|
|
29 #include <unistd.h>
|
|
30 #include <sys/stat.h>
|
|
31
|
|
32
|
|
33 static RcSection *bmp_rcfile_create_section(RcFile * file,
|
|
34 const gchar * name);
|
|
35 static RcLine *bmp_rcfile_create_string(RcSection * section,
|
|
36 const gchar * key,
|
|
37 const gchar * value);
|
|
38 static RcSection *bmp_rcfile_find_section(RcFile * file, const gchar * name);
|
|
39 static RcLine *bmp_rcfile_find_string(RcSection * section, const gchar * key);
|
|
40
|
2057
|
41 /**
|
|
42 * bmp_rcfile_new:
|
|
43 *
|
|
44 * #RcFile object factory.
|
|
45 *
|
|
46 * Return value: A #RcFile object.
|
|
47 **/
|
0
|
48 RcFile *
|
|
49 bmp_rcfile_new(void)
|
|
50 {
|
|
51 return g_new0(RcFile, 1);
|
|
52 }
|
|
53
|
2057
|
54 /**
|
|
55 * bmp_rcfile_free:
|
|
56 * @file: A #RcFile object to destroy.
|
|
57 *
|
|
58 * #RcFile object destructor.
|
|
59 **/
|
0
|
60 void
|
|
61 bmp_rcfile_free(RcFile * file)
|
|
62 {
|
|
63 RcSection *section;
|
|
64 RcLine *line;
|
|
65 GList *section_list, *line_list;
|
|
66
|
|
67 if (file == NULL)
|
|
68 return;
|
|
69
|
|
70 section_list = file->sections;
|
|
71 while (section_list) {
|
|
72 section = (RcSection *) section_list->data;
|
|
73 g_free(section->name);
|
|
74
|
|
75 line_list = section->lines;
|
|
76 while (line_list) {
|
|
77 line = (RcLine *) line_list->data;
|
|
78 g_free(line->key);
|
|
79 g_free(line->value);
|
|
80 g_free(line);
|
|
81 line_list = g_list_next(line_list);
|
|
82 }
|
|
83 g_list_free(section->lines);
|
|
84 g_free(section);
|
|
85
|
|
86 section_list = g_list_next(section_list);
|
|
87 }
|
|
88 g_list_free(file->sections);
|
|
89 g_free(file);
|
|
90 }
|
|
91
|
2057
|
92 /**
|
|
93 * bmp_rcfile_open:
|
|
94 * @filename: Path to rcfile to open.
|
|
95 *
|
|
96 * Opens an rcfile and returns an #RcFile object representing it.
|
|
97 *
|
|
98 * Return value: An #RcFile object representing the rcfile given.
|
|
99 **/
|
0
|
100 RcFile *
|
|
101 bmp_rcfile_open(const gchar * filename)
|
|
102 {
|
|
103 RcFile *file;
|
|
104
|
|
105 gchar *buffer, **lines, *tmp;
|
|
106 gint i;
|
|
107 RcSection *section = NULL;
|
|
108
|
|
109 g_return_val_if_fail(filename != NULL, FALSE);
|
|
110 g_return_val_if_fail(strlen(filename) > 0, FALSE);
|
|
111
|
|
112 if (!g_file_get_contents(filename, &buffer, NULL, NULL))
|
|
113 return NULL;
|
|
114
|
2057
|
115 file = bmp_rcfile_new();
|
0
|
116 lines = g_strsplit(buffer, "\n", 0);
|
|
117 g_free(buffer);
|
|
118 i = 0;
|
|
119 while (lines[i]) {
|
|
120 if (lines[i][0] == '[') {
|
|
121 if ((tmp = strchr(lines[i], ']'))) {
|
|
122 *tmp = '\0';
|
|
123 section = bmp_rcfile_create_section(file, &lines[i][1]);
|
|
124 }
|
|
125 }
|
|
126 else if (lines[i][0] != '#' && section) {
|
|
127 if ((tmp = strchr(lines[i], '='))) {
|
|
128 gchar **frags;
|
1769
|
129 frags = g_strsplit(lines[i], "=", 2);
|
0
|
130 if (strlen(frags[1]) > 0) {
|
|
131 bmp_rcfile_create_string(section, frags[0], frags[1]);
|
|
132 };
|
1327
|
133 g_strfreev(frags);
|
0
|
134 }
|
|
135 }
|
|
136 i++;
|
|
137 }
|
|
138 g_strfreev(lines);
|
|
139 return file;
|
|
140 }
|
|
141
|
2057
|
142 /**
|
|
143 * bmp_rcfile_write:
|
|
144 * @file: A #RcFile object to write to disk.
|
|
145 * @filename: A path to write the #RcFile object's data to.
|
|
146 *
|
|
147 * Writes the contents of a #RcFile object to disk.
|
|
148 *
|
|
149 * Return value: TRUE on success, FALSE otherwise.
|
|
150 **/
|
0
|
151 gboolean
|
|
152 bmp_rcfile_write(RcFile * file, const gchar * filename)
|
|
153 {
|
|
154 FILE *fp;
|
|
155 GList *section_list, *line_list;
|
|
156 RcSection *section;
|
|
157 RcLine *line;
|
|
158
|
|
159 g_return_val_if_fail(file != NULL, FALSE);
|
|
160 g_return_val_if_fail(filename != NULL, FALSE);
|
|
161
|
|
162 if (!(fp = fopen(filename, "w")))
|
|
163 return FALSE;
|
|
164
|
|
165 section_list = file->sections;
|
|
166 while (section_list) {
|
|
167 section = (RcSection *) section_list->data;
|
|
168 if (section->lines) {
|
|
169 fprintf(fp, "[%s]\n", section->name);
|
|
170 line_list = section->lines;
|
|
171 while (line_list) {
|
|
172 line = (RcLine *) line_list->data;
|
|
173 fprintf(fp, "%s=%s\n", line->key, line->value);
|
|
174 line_list = g_list_next(line_list);
|
|
175 }
|
|
176 fprintf(fp, "\n");
|
|
177 }
|
|
178 section_list = g_list_next(section_list);
|
|
179 }
|
|
180 fclose(fp);
|
|
181 return TRUE;
|
|
182 }
|
|
183
|
2057
|
184 /**
|
|
185 * bmp_rcfile_read_string:
|
|
186 * @file: A #RcFile object to write to disk.
|
|
187 * @section: The section of the RcFile to look in.
|
|
188 * @key: The name of the identifier to look up.
|
|
189 * @value: A pointer to a memory location to place the data.
|
|
190 *
|
|
191 * Looks up a value in an RcFile and places it in %value.
|
|
192 *
|
|
193 * Return value: TRUE on success, FALSE otherwise.
|
|
194 **/
|
0
|
195 gboolean
|
|
196 bmp_rcfile_read_string(RcFile * file, const gchar * section,
|
|
197 const gchar * key, gchar ** value)
|
|
198 {
|
|
199 RcSection *sect;
|
|
200 RcLine *line;
|
|
201
|
|
202 g_return_val_if_fail(file != NULL, FALSE);
|
|
203 g_return_val_if_fail(section != NULL, FALSE);
|
|
204 g_return_val_if_fail(key != NULL, FALSE);
|
|
205 g_return_val_if_fail(value != NULL, FALSE);
|
|
206
|
|
207 if (!(sect = bmp_rcfile_find_section(file, section)))
|
|
208 return FALSE;
|
|
209 if (!(line = bmp_rcfile_find_string(sect, key)))
|
|
210 return FALSE;
|
|
211 *value = g_strdup(line->value);
|
|
212 return TRUE;
|
|
213 }
|
|
214
|
2057
|
215 /**
|
|
216 * bmp_rcfile_read_int:
|
|
217 * @file: A #RcFile object to write to disk.
|
|
218 * @section: The section of the RcFile to look in.
|
|
219 * @key: The name of the identifier to look up.
|
|
220 * @value: A pointer to a memory location to place the data.
|
|
221 *
|
|
222 * Looks up a value in an RcFile and places it in %value.
|
|
223 *
|
|
224 * Return value: TRUE on success, FALSE otherwise.
|
|
225 **/
|
0
|
226 gboolean
|
|
227 bmp_rcfile_read_int(RcFile * file, const gchar * section,
|
|
228 const gchar * key, gint * value)
|
|
229 {
|
|
230 gchar *str;
|
|
231
|
|
232 g_return_val_if_fail(file != NULL, FALSE);
|
|
233 g_return_val_if_fail(section != NULL, FALSE);
|
|
234 g_return_val_if_fail(key != NULL, FALSE);
|
|
235 g_return_val_if_fail(value != NULL, FALSE);
|
|
236
|
|
237 if (!bmp_rcfile_read_string(file, section, key, &str))
|
|
238 return FALSE;
|
|
239 *value = atoi(str);
|
|
240 g_free(str);
|
|
241
|
|
242 return TRUE;
|
|
243 }
|
|
244
|
2057
|
245 /**
|
|
246 * bmp_rcfile_read_bool:
|
|
247 * @file: A #RcFile object to write to disk.
|
|
248 * @section: The section of the RcFile to look in.
|
|
249 * @key: The name of the identifier to look up.
|
|
250 * @value: A pointer to a memory location to place the data.
|
|
251 *
|
|
252 * Looks up a value in an RcFile and places it in %value.
|
|
253 *
|
|
254 * Return value: TRUE on success, FALSE otherwise.
|
|
255 **/
|
0
|
256 gboolean
|
|
257 bmp_rcfile_read_bool(RcFile * file, const gchar * section,
|
|
258 const gchar * key, gboolean * value)
|
|
259 {
|
|
260 gchar *str;
|
|
261
|
|
262 g_return_val_if_fail(file != NULL, FALSE);
|
|
263 g_return_val_if_fail(section != NULL, FALSE);
|
|
264 g_return_val_if_fail(key != NULL, FALSE);
|
|
265 g_return_val_if_fail(value != NULL, FALSE);
|
|
266
|
|
267 if (!bmp_rcfile_read_string(file, section, key, &str))
|
|
268 return FALSE;
|
|
269 if (!strcasecmp(str, "TRUE"))
|
|
270 *value = TRUE;
|
|
271 else
|
|
272 *value = FALSE;
|
|
273 g_free(str);
|
|
274 return TRUE;
|
|
275 }
|
|
276
|
2057
|
277 /**
|
|
278 * bmp_rcfile_read_float:
|
|
279 * @file: A #RcFile object to write to disk.
|
|
280 * @section: The section of the RcFile to look in.
|
|
281 * @key: The name of the identifier to look up.
|
|
282 * @value: A pointer to a memory location to place the data.
|
|
283 *
|
|
284 * Looks up a value in an RcFile and places it in %value.
|
|
285 *
|
|
286 * Return value: TRUE on success, FALSE otherwise.
|
|
287 **/
|
0
|
288 gboolean
|
|
289 bmp_rcfile_read_float(RcFile * file, const gchar * section,
|
|
290 const gchar * key, gfloat * value)
|
|
291 {
|
|
292 gchar *str, *locale;
|
|
293
|
|
294 g_return_val_if_fail(file != NULL, FALSE);
|
|
295 g_return_val_if_fail(section != NULL, FALSE);
|
|
296 g_return_val_if_fail(key != NULL, FALSE);
|
|
297 g_return_val_if_fail(value != NULL, FALSE);
|
|
298
|
|
299 if (!bmp_rcfile_read_string(file, section, key, &str))
|
|
300 return FALSE;
|
|
301
|
|
302 locale = g_strdup(setlocale(LC_NUMERIC, NULL));
|
|
303 setlocale(LC_NUMERIC, "C");
|
|
304 *value = strtod(str, NULL);
|
|
305 setlocale(LC_NUMERIC, locale);
|
|
306 g_free(locale);
|
|
307 g_free(str);
|
|
308
|
|
309 return TRUE;
|
|
310 }
|
|
311
|
2057
|
312 /**
|
|
313 * bmp_rcfile_read_double:
|
|
314 * @file: A #RcFile object to write to disk.
|
|
315 * @section: The section of the RcFile to look in.
|
|
316 * @key: The name of the identifier to look up.
|
|
317 * @value: A pointer to a memory location to place the data.
|
|
318 *
|
|
319 * Looks up a value in an RcFile and places it in %value.
|
|
320 *
|
|
321 * Return value: TRUE on success, FALSE otherwise.
|
|
322 **/
|
0
|
323 gboolean
|
|
324 bmp_rcfile_read_double(RcFile * file, const gchar * section,
|
|
325 const gchar * key, gdouble * value)
|
|
326 {
|
|
327 gchar *str, *locale;
|
|
328
|
|
329 g_return_val_if_fail(file != NULL, FALSE);
|
|
330 g_return_val_if_fail(section != NULL, FALSE);
|
|
331 g_return_val_if_fail(key != NULL, FALSE);
|
|
332 g_return_val_if_fail(value != NULL, FALSE);
|
|
333
|
|
334 if (!bmp_rcfile_read_string(file, section, key, &str))
|
|
335 return FALSE;
|
|
336
|
|
337 locale = g_strdup(setlocale(LC_NUMERIC, NULL));
|
|
338 setlocale(LC_NUMERIC, "C");
|
|
339 *value = strtod(str, NULL);
|
|
340 setlocale(LC_NUMERIC, locale);
|
|
341 g_free(locale);
|
|
342 g_free(str);
|
|
343
|
|
344 return TRUE;
|
|
345 }
|
|
346
|
2057
|
347 /**
|
|
348 * bmp_rcfile_write_string:
|
|
349 * @file: A #RcFile object to write to disk.
|
|
350 * @section: The section of the RcFile to set the key in.
|
|
351 * @key: The name of the identifier to set.
|
|
352 * @value: The value to set for that identifier.
|
|
353 *
|
|
354 * Sets a value in an RcFile for %key.
|
|
355 **/
|
0
|
356 void
|
|
357 bmp_rcfile_write_string(RcFile * file, const gchar * section,
|
|
358 const gchar * key, const gchar * value)
|
|
359 {
|
|
360 RcSection *sect;
|
|
361 RcLine *line;
|
|
362
|
|
363 g_return_if_fail(file != NULL);
|
|
364 g_return_if_fail(section != NULL);
|
|
365 g_return_if_fail(key != NULL);
|
|
366 g_return_if_fail(value != NULL);
|
|
367
|
|
368 sect = bmp_rcfile_find_section(file, section);
|
|
369 if (!sect)
|
|
370 sect = bmp_rcfile_create_section(file, section);
|
|
371 if ((line = bmp_rcfile_find_string(sect, key))) {
|
|
372 g_free(line->value);
|
|
373 line->value = g_strstrip(g_strdup(value));
|
|
374 }
|
|
375 else
|
|
376 bmp_rcfile_create_string(sect, key, value);
|
|
377 }
|
|
378
|
2057
|
379 /**
|
|
380 * bmp_rcfile_write_int:
|
|
381 * @file: A #RcFile object to write to disk.
|
|
382 * @section: The section of the RcFile to set the key in.
|
|
383 * @key: The name of the identifier to set.
|
|
384 * @value: The value to set for that identifier.
|
|
385 *
|
|
386 * Sets a value in an RcFile for %key.
|
|
387 **/
|
0
|
388 void
|
|
389 bmp_rcfile_write_int(RcFile * file, const gchar * section,
|
|
390 const gchar * key, gint value)
|
|
391 {
|
|
392 gchar *strvalue;
|
|
393
|
|
394 g_return_if_fail(file != NULL);
|
|
395 g_return_if_fail(section != NULL);
|
|
396 g_return_if_fail(key != NULL);
|
|
397
|
|
398 strvalue = g_strdup_printf("%d", value);
|
|
399 bmp_rcfile_write_string(file, section, key, strvalue);
|
|
400 g_free(strvalue);
|
|
401 }
|
|
402
|
2057
|
403 /**
|
|
404 * bmp_rcfile_write_boolean:
|
|
405 * @file: A #RcFile object to write to disk.
|
|
406 * @section: The section of the RcFile to set the key in.
|
|
407 * @key: The name of the identifier to set.
|
|
408 * @value: The value to set for that identifier.
|
|
409 *
|
|
410 * Sets a value in an RcFile for %key.
|
|
411 **/
|
0
|
412 void
|
|
413 bmp_rcfile_write_boolean(RcFile * file, const gchar * section,
|
|
414 const gchar * key, gboolean value)
|
|
415 {
|
|
416 g_return_if_fail(file != NULL);
|
|
417 g_return_if_fail(section != NULL);
|
|
418 g_return_if_fail(key != NULL);
|
|
419
|
|
420 if (value)
|
|
421 bmp_rcfile_write_string(file, section, key, "TRUE");
|
|
422 else
|
|
423 bmp_rcfile_write_string(file, section, key, "FALSE");
|
|
424 }
|
|
425
|
2057
|
426 /**
|
|
427 * bmp_rcfile_write_float:
|
|
428 * @file: A #RcFile object to write to disk.
|
|
429 * @section: The section of the RcFile to set the key in.
|
|
430 * @key: The name of the identifier to set.
|
|
431 * @value: The value to set for that identifier.
|
|
432 *
|
|
433 * Sets a value in an RcFile for %key.
|
|
434 **/
|
0
|
435 void
|
|
436 bmp_rcfile_write_float(RcFile * file, const gchar * section,
|
|
437 const gchar * key, gfloat value)
|
|
438 {
|
|
439 gchar *strvalue, *locale;
|
|
440
|
|
441 g_return_if_fail(file != NULL);
|
|
442 g_return_if_fail(section != NULL);
|
|
443 g_return_if_fail(key != NULL);
|
|
444
|
|
445 locale = g_strdup(setlocale(LC_NUMERIC, NULL));
|
|
446 setlocale(LC_NUMERIC, "C");
|
|
447 strvalue = g_strdup_printf("%g", value);
|
|
448 setlocale(LC_NUMERIC, locale);
|
|
449 bmp_rcfile_write_string(file, section, key, strvalue);
|
|
450 g_free(locale);
|
|
451 g_free(strvalue);
|
|
452 }
|
|
453
|
2057
|
454 /**
|
|
455 * bmp_rcfile_write_double:
|
|
456 * @file: A #RcFile object to write to disk.
|
|
457 * @section: The section of the RcFile to set the key in.
|
|
458 * @key: The name of the identifier to set.
|
|
459 * @value: The value to set for that identifier.
|
|
460 *
|
|
461 * Sets a value in an RcFile for %key.
|
|
462 **/
|
0
|
463 void
|
|
464 bmp_rcfile_write_double(RcFile * file, const gchar * section,
|
|
465 const gchar * key, gdouble value)
|
|
466 {
|
|
467 gchar *strvalue, *locale;
|
|
468
|
|
469 g_return_if_fail(file != NULL);
|
|
470 g_return_if_fail(section != NULL);
|
|
471 g_return_if_fail(key != NULL);
|
|
472
|
|
473 locale = g_strdup(setlocale(LC_NUMERIC, NULL));
|
|
474 setlocale(LC_NUMERIC, "C");
|
|
475 strvalue = g_strdup_printf("%g", value);
|
|
476 setlocale(LC_NUMERIC, locale);
|
|
477 bmp_rcfile_write_string(file, section, key, strvalue);
|
|
478 g_free(locale);
|
|
479 g_free(strvalue);
|
|
480 }
|
|
481
|
2057
|
482 /**
|
|
483 * bmp_rcfile_remove_key:
|
|
484 * @file: A #RcFile object to write to disk.
|
|
485 * @section: The section of the RcFile to set the key in.
|
|
486 * @key: The name of the identifier to remove.
|
|
487 *
|
|
488 * Removes %key from an #RcFile object.
|
|
489 **/
|
0
|
490 void
|
|
491 bmp_rcfile_remove_key(RcFile * file, const gchar * section, const gchar * key)
|
|
492 {
|
|
493 RcSection *sect;
|
|
494 RcLine *line;
|
|
495
|
|
496 g_return_if_fail(file != NULL);
|
|
497 g_return_if_fail(section != NULL);
|
|
498 g_return_if_fail(key != NULL);
|
|
499
|
|
500 if ((sect = bmp_rcfile_find_section(file, section)) != NULL) {
|
|
501 if ((line = bmp_rcfile_find_string(sect, key)) != NULL) {
|
|
502 g_free(line->key);
|
|
503 g_free(line->value);
|
|
504 g_free(line);
|
|
505 sect->lines = g_list_remove(sect->lines, line);
|
|
506 }
|
|
507 }
|
|
508 }
|
|
509
|
|
510 static RcSection *
|
|
511 bmp_rcfile_create_section(RcFile * file, const gchar * name)
|
|
512 {
|
|
513 RcSection *section;
|
|
514
|
|
515 section = g_new0(RcSection, 1);
|
|
516 section->name = g_strdup(name);
|
|
517 file->sections = g_list_append(file->sections, section);
|
|
518
|
|
519 return section;
|
|
520 }
|
|
521
|
|
522 static RcLine *
|
|
523 bmp_rcfile_create_string(RcSection * section,
|
|
524 const gchar * key, const gchar * value)
|
|
525 {
|
|
526 RcLine *line;
|
|
527
|
|
528 line = g_new0(RcLine, 1);
|
|
529 line->key = g_strstrip(g_strdup(key));
|
|
530 line->value = g_strstrip(g_strdup(value));
|
|
531 section->lines = g_list_append(section->lines, line);
|
|
532
|
|
533 return line;
|
|
534 }
|
|
535
|
|
536 static RcSection *
|
|
537 bmp_rcfile_find_section(RcFile * file, const gchar * name)
|
|
538 {
|
|
539 RcSection *section;
|
|
540 GList *list;
|
|
541
|
|
542 list = file->sections;
|
|
543 while (list) {
|
|
544 section = (RcSection *) list->data;
|
|
545 if (!strcasecmp(section->name, name))
|
|
546 return section;
|
|
547 list = g_list_next(list);
|
|
548 }
|
|
549 return NULL;
|
|
550 }
|
|
551
|
|
552 static RcLine *
|
|
553 bmp_rcfile_find_string(RcSection * section, const gchar * key)
|
|
554 {
|
|
555 RcLine *line;
|
|
556 GList *list;
|
|
557
|
|
558 list = section->lines;
|
|
559 while (list) {
|
|
560 line = (RcLine *) list->data;
|
|
561 if (!strcasecmp(line->key, key))
|
|
562 return line;
|
|
563 list = g_list_next(list);
|
|
564 }
|
|
565 return NULL;
|
|
566 }
|