diff options
Diffstat (limited to 'scripts/config/confdata.c')
-rw-r--r-- | scripts/config/confdata.c | 245 |
1 files changed, 154 insertions, 91 deletions
diff --git a/scripts/config/confdata.c b/scripts/config/confdata.c index 0d24ac52f..c6a2864dc 100644 --- a/scripts/config/confdata.c +++ b/scripts/config/confdata.c | |||
@@ -1,11 +1,9 @@ | |||
1 | /* | 1 | /* |
2 | * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org> | 2 | * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org> |
3 | * Released under the terms of the GNU GPL v2.0. | 3 | * Released under the terms of the GNU GPL v2.0. |
4 | * | ||
5 | * Allow 'n' as a symbol value. | ||
6 | * 2002-11-05 Petr Baudis <pasky@ucw.cz> | ||
7 | */ | 4 | */ |
8 | 5 | ||
6 | #include <sys/stat.h> | ||
9 | #include <ctype.h> | 7 | #include <ctype.h> |
10 | #include <stdio.h> | 8 | #include <stdio.h> |
11 | #include <stdlib.h> | 9 | #include <stdlib.h> |
@@ -38,7 +36,7 @@ static char *conf_expand_value(const char *in) | |||
38 | strncat(res_value, in, src - in); | 36 | strncat(res_value, in, src - in); |
39 | src++; | 37 | src++; |
40 | dst = name; | 38 | dst = name; |
41 | while (isalnum((int)*src) || *src == '_') | 39 | while (isalnum(*src) || *src == '_') |
42 | *dst++ = *src++; | 40 | *dst++ = *src++; |
43 | *dst = 0; | 41 | *dst = 0; |
44 | sym = sym_lookup(name, 0); | 42 | sym = sym_lookup(name, 0); |
@@ -53,7 +51,18 @@ static char *conf_expand_value(const char *in) | |||
53 | 51 | ||
54 | char *conf_get_default_confname(void) | 52 | char *conf_get_default_confname(void) |
55 | { | 53 | { |
56 | return conf_expand_value(conf_defname); | 54 | struct stat buf; |
55 | static char fullname[4096+1]; | ||
56 | char *env, *name; | ||
57 | |||
58 | name = conf_expand_value(conf_defname); | ||
59 | env = getenv(SRCTREE); | ||
60 | if (env) { | ||
61 | sprintf(fullname, "%s/%s", env, name); | ||
62 | if (!stat(fullname, &buf)) | ||
63 | return fullname; | ||
64 | } | ||
65 | return name; | ||
57 | } | 66 | } |
58 | 67 | ||
59 | int conf_read(const char *name) | 68 | int conf_read(const char *name) |
@@ -68,12 +77,12 @@ int conf_read(const char *name) | |||
68 | int i; | 77 | int i; |
69 | 78 | ||
70 | if (name) { | 79 | if (name) { |
71 | in = fopen(name, "r"); | 80 | in = zconf_fopen(name); |
72 | } else { | 81 | } else { |
73 | const char **names = conf_confnames; | 82 | const char **names = conf_confnames; |
74 | while ((name = *names++)) { | 83 | while ((name = *names++)) { |
75 | name = conf_expand_value(name); | 84 | name = conf_expand_value(name); |
76 | in = fopen(name, "r"); | 85 | in = zconf_fopen(name); |
77 | if (in) { | 86 | if (in) { |
78 | printf("#\n" | 87 | printf("#\n" |
79 | "# using defaults found in %s\n" | 88 | "# using defaults found in %s\n" |
@@ -93,44 +102,43 @@ int conf_read(const char *name) | |||
93 | case S_INT: | 102 | case S_INT: |
94 | case S_HEX: | 103 | case S_HEX: |
95 | case S_STRING: | 104 | case S_STRING: |
96 | if (S_VAL(sym->def)) | 105 | if (sym->user.val) |
97 | free(S_VAL(sym->def)); | 106 | free(sym->user.val); |
98 | default: | 107 | default: |
99 | S_VAL(sym->def) = NULL; | 108 | sym->user.val = NULL; |
100 | S_TRI(sym->def) = no; | 109 | sym->user.tri = no; |
101 | ; | ||
102 | } | 110 | } |
103 | } | 111 | } |
104 | 112 | ||
105 | while (fgets(line, sizeof(line), in)) { | 113 | while (fgets(line, sizeof(line), in)) { |
106 | lineno++; | 114 | lineno++; |
115 | sym = NULL; | ||
107 | switch (line[0]) { | 116 | switch (line[0]) { |
108 | case '\n': | ||
109 | break; | ||
110 | case ' ': | ||
111 | break; | ||
112 | case '#': | 117 | case '#': |
113 | p = strchr(line, ' '); | 118 | if (line[1]!=' ') |
114 | if (!p) | ||
115 | continue; | 119 | continue; |
116 | *p++ = 0; | 120 | p = strchr(line + 2, ' '); |
117 | p = strchr(p, ' '); | ||
118 | if (!p) | 121 | if (!p) |
119 | continue; | 122 | continue; |
120 | *p++ = 0; | 123 | *p++ = 0; |
121 | if (strncmp(p, "is not set", 10)) | 124 | if (strncmp(p, "is not set", 10)) |
122 | continue; | 125 | continue; |
123 | sym = sym_lookup(line+2, 0); | 126 | sym = sym_find(line + 2); |
127 | if (!sym) { | ||
128 | fprintf(stderr, "%s:%d: trying to assign nonexistent symbol %s\n", name, lineno, line + 2); | ||
129 | break; | ||
130 | } | ||
124 | switch (sym->type) { | 131 | switch (sym->type) { |
125 | case S_BOOLEAN: | 132 | case S_BOOLEAN: |
126 | case S_TRISTATE: | 133 | case S_TRISTATE: |
127 | sym->def = symbol_no.curr; | 134 | sym->user.tri = no; |
128 | sym->flags &= ~SYMBOL_NEW; | 135 | sym->flags &= ~SYMBOL_NEW; |
129 | break; | 136 | break; |
130 | default: | 137 | default: |
131 | ; | 138 | ; |
132 | } | 139 | } |
133 | break; | 140 | break; |
141 | |||
134 | case 'A' ... 'Z': | 142 | case 'A' ... 'Z': |
135 | p = strchr(line, '='); | 143 | p = strchr(line, '='); |
136 | if (!p) | 144 | if (!p) |
@@ -145,24 +153,24 @@ int conf_read(const char *name) | |||
145 | break; | 153 | break; |
146 | } | 154 | } |
147 | switch (sym->type) { | 155 | switch (sym->type) { |
148 | case S_TRISTATE: | 156 | case S_TRISTATE: |
149 | if (p[0] == 'm') { | 157 | if (p[0] == 'm') { |
150 | S_TRI(sym->def) = mod; | 158 | sym->user.tri = mod; |
151 | sym->flags &= ~SYMBOL_NEW; | 159 | sym->flags &= ~SYMBOL_NEW; |
152 | break; | 160 | break; |
153 | } | 161 | } |
154 | case S_BOOLEAN: | 162 | case S_BOOLEAN: |
155 | if (p[0] == 'y') { | 163 | if (p[0] == 'y') { |
156 | S_TRI(sym->def) = yes; | 164 | sym->user.tri = yes; |
157 | sym->flags &= ~SYMBOL_NEW; | 165 | sym->flags &= ~SYMBOL_NEW; |
158 | break; | 166 | break; |
159 | } | 167 | } |
160 | if (p[0] == 'n') { | 168 | if (p[0] == 'n') { |
161 | S_TRI(sym->def) = no; | 169 | sym->user.tri = no; |
162 | sym->flags &= ~SYMBOL_NEW; | 170 | sym->flags &= ~SYMBOL_NEW; |
163 | break; | 171 | break; |
164 | } | 172 | } |
165 | break; | 173 | break; |
166 | case S_STRING: | 174 | case S_STRING: |
167 | if (*p++ != '"') | 175 | if (*p++ != '"') |
168 | break; | 176 | break; |
@@ -173,48 +181,71 @@ int conf_read(const char *name) | |||
173 | } | 181 | } |
174 | memmove(p2, p2 + 1, strlen(p2)); | 182 | memmove(p2, p2 + 1, strlen(p2)); |
175 | } | 183 | } |
184 | if (!p2) { | ||
185 | fprintf(stderr, "%s:%d: invalid string found\n", name, lineno); | ||
186 | exit(1); | ||
187 | } | ||
176 | case S_INT: | 188 | case S_INT: |
177 | case S_HEX: | 189 | case S_HEX: |
178 | if (sym_string_valid(sym, p)) { | 190 | if (sym_string_valid(sym, p)) { |
179 | S_VAL(sym->def) = strdup(p); | 191 | sym->user.val = strdup(p); |
180 | sym->flags &= ~SYMBOL_NEW; | 192 | sym->flags &= ~SYMBOL_NEW; |
181 | } else | 193 | } else { |
182 | fprintf(stderr, "%s:%d:symbol value '%s' invalid for %s\n", name, lineno, p, sym->name); | 194 | fprintf(stderr, "%s:%d: symbol value '%s' invalid for %s\n", name, lineno, p, sym->name); |
195 | exit(1); | ||
196 | } | ||
183 | break; | 197 | break; |
184 | default: | 198 | default: |
185 | ; | 199 | ; |
186 | } | 200 | } |
187 | if (sym_is_choice_value(sym)) { | 201 | break; |
188 | prop = sym_get_choice_prop(sym); | 202 | case '\n': |
189 | switch (S_TRI(sym->def)) { | ||
190 | case mod: | ||
191 | if (S_TRI(prop->def->def) == yes) | ||
192 | /* warn? */; | ||
193 | break; | ||
194 | case yes: | ||
195 | if (S_TRI(prop->def->def) != no) | ||
196 | /* warn? */; | ||
197 | S_VAL(prop->def->def) = sym; | ||
198 | break; | ||
199 | case no: | ||
200 | break; | ||
201 | } | ||
202 | S_TRI(prop->def->def) = S_TRI(sym->def); | ||
203 | } | ||
204 | break; | 203 | break; |
205 | default: | 204 | default: |
206 | continue; | 205 | continue; |
207 | } | 206 | } |
207 | if (sym && sym_is_choice_value(sym)) { | ||
208 | struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym)); | ||
209 | switch (sym->user.tri) { | ||
210 | case no: | ||
211 | break; | ||
212 | case mod: | ||
213 | if (cs->user.tri == yes) | ||
214 | /* warn? */; | ||
215 | break; | ||
216 | case yes: | ||
217 | if (cs->user.tri != no) | ||
218 | /* warn? */; | ||
219 | cs->user.val = sym; | ||
220 | break; | ||
221 | } | ||
222 | cs->user.tri = E_OR(cs->user.tri, sym->user.tri); | ||
223 | cs->flags &= ~SYMBOL_NEW; | ||
224 | } | ||
208 | } | 225 | } |
209 | fclose(in); | 226 | fclose(in); |
210 | 227 | ||
211 | for_all_symbols(i, sym) { | 228 | for_all_symbols(i, sym) { |
229 | sym_calc_value(sym); | ||
230 | if (sym_has_value(sym) && !sym_is_choice_value(sym)) { | ||
231 | if (sym->visible == no) | ||
232 | sym->flags |= SYMBOL_NEW; | ||
233 | switch (sym->type) { | ||
234 | case S_STRING: | ||
235 | case S_INT: | ||
236 | case S_HEX: | ||
237 | if (!sym_string_within_range(sym, sym->user.val)) | ||
238 | sym->flags |= SYMBOL_NEW; | ||
239 | default: | ||
240 | break; | ||
241 | } | ||
242 | } | ||
212 | if (!sym_is_choice(sym)) | 243 | if (!sym_is_choice(sym)) |
213 | continue; | 244 | continue; |
214 | prop = sym_get_choice_prop(sym); | 245 | prop = sym_get_choice_prop(sym); |
215 | for (e = prop->dep; e; e = e->left.expr) | 246 | for (e = prop->expr; e; e = e->left.expr) |
216 | sym->flags |= e->right.sym->flags & SYMBOL_NEW; | 247 | if (e->right.sym->visible != no) |
217 | sym->flags &= ~SYMBOL_NEW; | 248 | sym->flags |= e->right.sym->flags & SYMBOL_NEW; |
218 | } | 249 | } |
219 | 250 | ||
220 | sym_change_count = 1; | 251 | sym_change_count = 1; |
@@ -227,29 +258,50 @@ int conf_write(const char *name) | |||
227 | FILE *out, *out_h; | 258 | FILE *out, *out_h; |
228 | struct symbol *sym; | 259 | struct symbol *sym; |
229 | struct menu *menu; | 260 | struct menu *menu; |
230 | char oldname[128]; | 261 | const char *basename; |
262 | char dirname[128], tmpname[128], newname[128]; | ||
231 | int type, l; | 263 | int type, l; |
232 | const char *str; | 264 | const char *str; |
233 | 265 | ||
234 | out = fopen(".tmpconfig", "w"); | 266 | dirname[0] = 0; |
267 | if (name && name[0]) { | ||
268 | char *slash = strrchr(name, '/'); | ||
269 | if (slash) { | ||
270 | int size = slash - name + 1; | ||
271 | memcpy(dirname, name, size); | ||
272 | dirname[size] = 0; | ||
273 | if (slash[1]) | ||
274 | basename = slash + 1; | ||
275 | else | ||
276 | basename = conf_def_filename; | ||
277 | } else | ||
278 | basename = name; | ||
279 | } else | ||
280 | basename = conf_def_filename; | ||
281 | |||
282 | sprintf(newname, "%s.tmpconfig.%d", dirname, getpid()); | ||
283 | out = fopen(newname, "w"); | ||
235 | if (!out) | 284 | if (!out) |
236 | return 1; | 285 | return 1; |
237 | out_h = fopen(".tmpconfig.h", "w"); | 286 | out_h = NULL; |
238 | if (!out_h) | 287 | if (!name) { |
239 | return 1; | 288 | out_h = fopen(".tmpconfig.h", "w"); |
289 | if (!out_h) | ||
290 | return 1; | ||
291 | } | ||
240 | fprintf(out, "#\n" | 292 | fprintf(out, "#\n" |
241 | "# Automatically generated make config: don't edit\n" | 293 | "# Automatically generated make config: don't edit\n" |
242 | "#\n"); | 294 | "#\n"); |
243 | fprintf(out_h, "/*\n" | 295 | if (out_h) |
244 | " * Automatically generated header file: don't edit\n" | 296 | fprintf(out_h, "/*\n" |
245 | " */\n\n" | 297 | " * Automatically generated header file: don't edit\n" |
246 | "#define AUTOCONF_INCLUDED\n\n" | 298 | " */\n\n" |
247 | "/* Version Number */\n" | 299 | "#define AUTOCONF_INCLUDED\n\n" |
248 | "#define BB_VER \"%s\"\n" | 300 | "/* Version Number */\n" |
249 | "#define BB_BT \"%s\"\n\n", | 301 | "#define BB_VER \"%s\"\n" |
250 | getenv("VERSION"), | 302 | "#define BB_BT \"%s\"\n\n", |
251 | getenv("BUILDTIME") | 303 | getenv("VERSION"), |
252 | ); | 304 | getenv("BUILDTIME")); |
253 | 305 | ||
254 | if (!sym_change_count) | 306 | if (!sym_change_count) |
255 | sym_clear_all_valid(); | 307 | sym_clear_all_valid(); |
@@ -265,10 +317,11 @@ int conf_write(const char *name) | |||
265 | "#\n" | 317 | "#\n" |
266 | "# %s\n" | 318 | "# %s\n" |
267 | "#\n", str); | 319 | "#\n", str); |
268 | fprintf(out_h, "\n" | 320 | if (out_h) |
269 | "/*\n" | 321 | fprintf(out_h, "\n" |
270 | " * %s\n" | 322 | "/*\n" |
271 | " */\n", str); | 323 | " * %s\n" |
324 | " */\n", str); | ||
272 | } else if (!(sym->flags & SYMBOL_CHOICE)) { | 325 | } else if (!(sym->flags & SYMBOL_CHOICE)) { |
273 | sym_calc_value(sym); | 326 | sym_calc_value(sym); |
274 | if (!(sym->flags & SYMBOL_WRITE)) | 327 | if (!(sym->flags & SYMBOL_WRITE)) |
@@ -277,7 +330,7 @@ int conf_write(const char *name) | |||
277 | type = sym->type; | 330 | type = sym->type; |
278 | if (type == S_TRISTATE) { | 331 | if (type == S_TRISTATE) { |
279 | sym_calc_value(modules_sym); | 332 | sym_calc_value(modules_sym); |
280 | if (S_TRI(modules_sym->curr) == no) | 333 | if (modules_sym->curr.tri == no) |
281 | type = S_BOOLEAN; | 334 | type = S_BOOLEAN; |
282 | } | 335 | } |
283 | switch (type) { | 336 | switch (type) { |
@@ -286,17 +339,20 @@ int conf_write(const char *name) | |||
286 | switch (sym_get_tristate_value(sym)) { | 339 | switch (sym_get_tristate_value(sym)) { |
287 | case no: | 340 | case no: |
288 | fprintf(out, "# %s is not set\n", sym->name); | 341 | fprintf(out, "# %s is not set\n", sym->name); |
289 | fprintf(out_h, "#undef %s\n", sym->name); | 342 | if (out_h) |
343 | fprintf(out_h, "#undef %s\n", sym->name); | ||
290 | break; | 344 | break; |
291 | case mod: | ||
292 | #if 0 | 345 | #if 0 |
346 | case mod: | ||
293 | fprintf(out, "%s=m\n", sym->name); | 347 | fprintf(out, "%s=m\n", sym->name); |
294 | fprintf(out_h, "#define __%s__MODULE 1\n", sym->name); | 348 | if (out_h) |
295 | #endif | 349 | fprintf(out_h, "#define %s_MODULE 1\n", sym->name); |
296 | break; | 350 | break; |
351 | #endif | ||
297 | case yes: | 352 | case yes: |
298 | fprintf(out, "%s=y\n", sym->name); | 353 | fprintf(out, "%s=y\n", sym->name); |
299 | fprintf(out_h, "#define %s 1\n", sym->name); | 354 | if (out_h) |
355 | fprintf(out_h, "#define %s 1\n", sym->name); | ||
300 | break; | 356 | break; |
301 | } | 357 | } |
302 | break; | 358 | break; |
@@ -304,34 +360,40 @@ int conf_write(const char *name) | |||
304 | // fix me | 360 | // fix me |
305 | str = sym_get_string_value(sym); | 361 | str = sym_get_string_value(sym); |
306 | fprintf(out, "%s=\"", sym->name); | 362 | fprintf(out, "%s=\"", sym->name); |
307 | fprintf(out_h, "#define %s \"", sym->name); | 363 | if (out_h) |
364 | fprintf(out_h, "#define %s \"", sym->name); | ||
308 | do { | 365 | do { |
309 | l = strcspn(str, "\"\\"); | 366 | l = strcspn(str, "\"\\"); |
310 | if (l) { | 367 | if (l) { |
311 | fwrite(str, l, 1, out); | 368 | fwrite(str, l, 1, out); |
312 | fwrite(str, l, 1, out_h); | 369 | if (out_h) |
370 | fwrite(str, l, 1, out_h); | ||
313 | } | 371 | } |
314 | str += l; | 372 | str += l; |
315 | while (*str == '\\' || *str == '"') { | 373 | while (*str == '\\' || *str == '"') { |
316 | fprintf(out, "\\%c", *str); | 374 | fprintf(out, "\\%c", *str); |
317 | fprintf(out_h, "\\%c", *str); | 375 | if (out_h) |
376 | fprintf(out_h, "\\%c", *str); | ||
318 | str++; | 377 | str++; |
319 | } | 378 | } |
320 | } while (*str); | 379 | } while (*str); |
321 | fputs("\"\n", out); | 380 | fputs("\"\n", out); |
322 | fputs("\"\n", out_h); | 381 | if (out_h) |
382 | fputs("\"\n", out_h); | ||
323 | break; | 383 | break; |
324 | case S_HEX: | 384 | case S_HEX: |
325 | str = sym_get_string_value(sym); | 385 | str = sym_get_string_value(sym); |
326 | if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) { | 386 | if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) { |
327 | fprintf(out, "%s=%s\n", sym->name, str); | 387 | fprintf(out, "%s=%s\n", sym->name, str); |
328 | fprintf(out_h, "#define %s 0x%s\n", sym->name, str); | 388 | if (out_h) |
389 | fprintf(out_h, "#define %s 0x%s\n", sym->name, str); | ||
329 | break; | 390 | break; |
330 | } | 391 | } |
331 | case S_INT: | 392 | case S_INT: |
332 | str = sym_get_string_value(sym); | 393 | str = sym_get_string_value(sym); |
333 | fprintf(out, "%s=%s\n", sym->name, str); | 394 | fprintf(out, "%s=%s\n", sym->name, str); |
334 | fprintf(out_h, "#define %s %s\n", sym->name, str); | 395 | if (out_h) |
396 | fprintf(out_h, "#define %s %s\n", sym->name, str); | ||
335 | break; | 397 | break; |
336 | } | 398 | } |
337 | } | 399 | } |
@@ -351,18 +413,19 @@ int conf_write(const char *name) | |||
351 | } | 413 | } |
352 | } | 414 | } |
353 | fclose(out); | 415 | fclose(out); |
354 | fclose(out_h); | 416 | if (out_h) { |
355 | 417 | fclose(out_h); | |
356 | if (!name) { | ||
357 | rename(".tmpconfig.h", "include/config.h"); | 418 | rename(".tmpconfig.h", "include/config.h"); |
358 | name = conf_def_filename; | ||
359 | file_write_dep(NULL); | 419 | file_write_dep(NULL); |
360 | } else | 420 | } |
361 | unlink(".tmpconfig.h"); | 421 | if (!name || basename != conf_def_filename) { |
362 | 422 | if (!name) | |
363 | sprintf(oldname, "%s.old", name); | 423 | name = conf_def_filename; |
364 | rename(name, oldname); | 424 | sprintf(tmpname, "%s.old", name); |
365 | if (rename(".tmpconfig", name)) | 425 | rename(name, tmpname); |
426 | } | ||
427 | sprintf(tmpname, "%s%s", dirname, basename); | ||
428 | if (rename(newname, tmpname)) | ||
366 | return 1; | 429 | return 1; |
367 | 430 | ||
368 | sym_change_count = 0; | 431 | sym_change_count = 0; |