1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// Demonstrates almost all of libpom's API
#include <pom.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <inttypes.h>
#include <assert.h>
static size_t custom_read(void *udata, char *buf, size_t size) {
int fd = (int)(intptr_t)udata;
size_t total_read = 0;
while (true) {
// must call read in a loop to fill buf up as much as possible!
// (read isn't guaranteed to read len bytes even if it could)
ssize_t ret = read(fd, buf, size);
if (ret <= 0) {
// read error/end-of-file
break;
} else {
total_read += ret;
buf += ret;
size -= ret;
}
}
return total_read;
}
int main(void) {
pom_error *error;
// ordinary usage: load from a path
pom_conf *conf = pom_load_path(NULL, "conf.pom", &error);
if (error) {
pom_error_print(error);
free(error);
return EXIT_FAILURE;
}
// get a key
const char *indentation_type = pom_conf_get(conf, "indentation-type");
printf("indentation-type: %s\n", indentation_type ? indentation_type : "(none)");
// free configuration
pom_conf_free(conf);
pom_settings settings = {0};
strcpy(settings.error_lang, "fr"); // erreurs en français
// load configuration with custom settings and a custom reader
int fd = open("conf.pom", O_RDONLY);
conf = pom_load(&settings,
"conf.pom", // file name for error messages
custom_read, // read function
(void *)(intptr_t)fd, // will be passed as 1st argument to custom_read
&error
);
if (error) {
pom_error_print(error);
free(error);
return EXIT_FAILURE;
}
// nicer way of doing what we did above
printf("indentation-type: %s\n", pom_conf_get_or_default(conf, "indentation-type", "(none)"));
// parse value as signed integer
int64_t int_val;
if ((error = pom_conf_get_int(conf, "tab-size", &int_val))) {
pom_error_print(error);
free(error);
} else {
printf("tab size: %" PRId64 "\n", int_val);
}
// parse value as unsigned integer, use default of 2
uint64_t uint_val;
if ((error = pom_conf_get_uint_or_default(conf, "padding-pixels", &uint_val, 2))) {
pom_error_print(error);
free(error);
} else {
printf("padding pixels: %" PRIu64 "\n", uint_val);
}
// parse value as double
double float_val;
if ((error = pom_conf_get_float_or_default(conf, "font-size", &float_val, 12.0))) {
pom_error_print(error);
free(error);
} else {
printf("font size: %f\n", float_val);
}
// parse value as boolean
bool bool_val;
if ((error = pom_conf_get_bool_or_default(conf, "show-line-numbers", &bool_val, true))) {
pom_error_print(error);
free(error);
} else {
printf("show line numbers: %d\n", bool_val);
}
// extract section out of configuration
const pom_conf *file_extensions = pom_conf_section(conf, "file-extensions");
// parse value as list
char **Cpp_extensions = pom_conf_get_list(file_extensions, "Cpp");
if (Cpp_extensions) {
for (size_t i = 0; Cpp_extensions[i]; i++)
printf("- Defined C++ extension %s\n", Cpp_extensions[i]);
} else {
printf("no extensions defined for C++\n");
}
free(Cpp_extensions);
// iterate over keys in section
pom_key_iter *key_iter = NULL;
const char *key;
const pom_conf *plugins = pom_conf_section(conf, "plug-in");
while ((key = pom_conf_next_key(plugins, &key_iter))) {
const pom_conf *plugin = pom_conf_section(plugins, key);
const char *path = pom_conf_get_or_default(plugin, "path", "(none)");
bool enabled;
if ((error = pom_conf_get_bool_or_default(plugin, "enabled", &enabled, true))) {
pom_error_print(error);
free(error);
// (enabled will still be true in this case)
}
// get location where key was defined
const char *file;
uint64_t line;
pom_conf_location(plugins, key, &file, &line);
printf("%s:%" PRIu64 ": plug-in: %s (path = %s, enabled = %d)\n",
file, line, key, path, enabled);
}
// load config from string
pom_conf *overrides = pom_load_string(NULL, "<built-in overrides>",
"tab-size = 12", &error);
assert(!error);
// create a copy of a configuration
pom_conf *copy = pom_conf_copy(conf);
// merge configurations
pom_conf_merge(copy, overrides);
// iterate over items (key-value pairs) in configuration
const pom_item *item;
pom_item_iter *item_iter = NULL;
while ((item = pom_conf_next_item(copy, &item_iter))) {
if (strchr(item->key, 'b'))
printf("\t%s: %s\n", item->key, item->value);
}
// iterate over all the keys which haven't been accessed directly
pom_unread_key_iter *unread_iter = NULL;
const char *unread;
while ((unread = pom_conf_next_unread_key(copy, &unread_iter))) {
printf("unrecognized key %s\n", unread);
}
pom_conf_free(copy);
pom_conf_free(overrides);
pom_conf_free(conf);
return 0;
}
|
