OpenWrt – Diff between revs 2 and 3
?pathlinks?
Rev 2 | Rev 3 | |||
---|---|---|---|---|
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 | */ |
4 | */ |
|
5 | |
5 | |
|
6 | #include <locale.h> |
6 | #include <locale.h> |
|
7 | #include <ctype.h> |
7 | #include <ctype.h> |
|
8 | #include <limits.h> |
8 | #include <limits.h> |
|
9 | #include <stdio.h> |
9 | #include <stdio.h> |
|
10 | #include <stdlib.h> |
10 | #include <stdlib.h> |
|
11 | #include <string.h> |
11 | #include <string.h> |
|
12 | #include <time.h> |
12 | #include <time.h> |
|
13 | #include <unistd.h> |
13 | #include <unistd.h> |
|
14 | #include <getopt.h> |
14 | #include <getopt.h> |
|
15 | #include <sys/stat.h> |
15 | #include <sys/stat.h> |
|
16 | #include <sys/time.h> |
16 | #include <sys/time.h> |
|
17 | #include <errno.h> |
17 | #include <errno.h> |
|
18 | |
18 | |
|
19 | #include "lkc.h" |
19 | #include "lkc.h" |
|
20 | |
20 | |
|
21 | static void conf(struct menu *menu); |
21 | static void conf(struct menu *menu); |
|
22 | static void check_conf(struct menu *menu); |
22 | static void check_conf(struct menu *menu); |
|
23 | static void xfgets(char *str, int size, FILE *in); |
23 | static void xfgets(char *str, int size, FILE *in); |
|
24 | |
24 | |
|
25 | enum input_mode { |
25 | enum input_mode { |
|
26 | oldaskconfig, |
26 | oldaskconfig, |
|
27 | silentoldconfig, |
27 | silentoldconfig, |
|
28 | oldconfig, |
28 | oldconfig, |
|
29 | allnoconfig, |
29 | allnoconfig, |
|
30 | allyesconfig, |
30 | allyesconfig, |
|
31 | allmodconfig, |
31 | allmodconfig, |
|
32 | alldefconfig, |
32 | alldefconfig, |
|
33 | randconfig, |
33 | randconfig, |
|
34 | defconfig, |
34 | defconfig, |
|
35 | savedefconfig, |
35 | savedefconfig, |
|
36 | listnewconfig, |
36 | listnewconfig, |
|
37 | olddefconfig, |
37 | olddefconfig, |
|
38 | } input_mode = oldaskconfig; |
38 | } input_mode = oldaskconfig; |
|
39 | |
39 | |
|
40 | static int indent = 1; |
40 | static int indent = 1; |
|
41 | static int tty_stdio; |
41 | static int tty_stdio; |
|
42 | static int valid_stdin = 1; |
42 | static int valid_stdin = 1; |
|
43 | static int sync_kconfig; |
43 | static int sync_kconfig; |
|
44 | static int conf_cnt; |
44 | static int conf_cnt; |
|
45 | static char line[PATH_MAX]; |
45 | static char line[PATH_MAX]; |
|
46 | static struct menu *rootEntry; |
46 | static struct menu *rootEntry; |
|
47 | |
47 | |
|
48 | static void print_help(struct menu *menu) |
48 | static void print_help(struct menu *menu) |
|
49 | { |
49 | { |
|
50 | struct gstr help = str_new(); |
50 | struct gstr help = str_new(); |
|
51 | |
51 | |
|
52 | menu_get_ext_help(menu, &help); |
52 | menu_get_ext_help(menu, &help); |
|
53 | |
53 | |
|
54 | printf("\n%s\n", str_get(&help)); |
54 | printf("\n%s\n", str_get(&help)); |
|
55 | str_free(&help); |
55 | str_free(&help); |
|
56 | } |
56 | } |
|
57 | |
57 | |
|
58 | static void strip(char *str) |
58 | static void strip(char *str) |
|
59 | { |
59 | { |
|
60 | char *p = str; |
60 | char *p = str; |
|
61 | int l; |
61 | int l; |
|
62 | |
62 | |
|
63 | while ((isspace(*p))) |
63 | while ((isspace(*p))) |
|
64 | p++; |
64 | p++; |
|
65 | l = strlen(p); |
65 | l = strlen(p); |
|
66 | if (p != str) |
66 | if (p != str) |
|
67 | memmove(str, p, l + 1); |
67 | memmove(str, p, l + 1); |
|
68 | if (!l) |
68 | if (!l) |
|
69 | return; |
69 | return; |
|
70 | p = str + l - 1; |
70 | p = str + l - 1; |
|
71 | while ((isspace(*p))) |
71 | while ((isspace(*p))) |
|
72 | *p-- = 0; |
72 | *p-- = 0; |
|
73 | } |
73 | } |
|
74 | |
74 | |
|
75 | static void check_stdin(void) |
75 | static void check_stdin(void) |
|
76 | { |
76 | { |
|
77 | if (!valid_stdin) { |
77 | if (!valid_stdin) { |
|
78 | printf("%s",_("aborted!\n\n")); |
78 | printf(_("aborted!\n\n")); |
|
79 | printf("%s",_("Console input/output is redirected. ")); |
79 | printf(_("Console input/output is redirected. ")); |
|
80 | printf("%s",_("Run 'make oldconfig' to update configuration.\n\n")); |
80 | printf(_("Run 'make oldconfig' to update configuration.\n\n")); |
|
81 | exit(1); |
81 | exit(1); |
|
82 | } |
82 | } |
|
83 | } |
83 | } |
|
84 | |
84 | |
|
85 | static int conf_askvalue(struct symbol *sym, const char *def) |
85 | static int conf_askvalue(struct symbol *sym, const char *def) |
|
86 | { |
86 | { |
|
87 | enum symbol_type type = sym_get_type(sym); |
87 | enum symbol_type type = sym_get_type(sym); |
|
88 | |
88 | |
|
89 | if (!sym_has_value(sym)) |
89 | if (!sym_has_value(sym)) |
|
90 | printf("%s",_("(NEW) ")); |
90 | printf(_("(NEW) ")); |
|
91 | |
91 | |
|
92 | line[0] = '\n'; |
92 | line[0] = '\n'; |
|
93 | line[1] = 0; |
93 | line[1] = 0; |
|
94 | |
94 | |
|
95 | if (!sym_is_changable(sym)) { |
95 | if (!sym_is_changable(sym)) { |
|
96 | printf("%s\n", def); |
96 | printf("%s\n", def); |
|
97 | line[0] = '\n'; |
97 | line[0] = '\n'; |
|
98 | line[1] = 0; |
98 | line[1] = 0; |
|
99 | return 0; |
99 | return 0; |
|
100 | } |
100 | } |
|
101 | |
101 | |
|
102 | switch (input_mode) { |
102 | switch (input_mode) { |
|
103 | case oldconfig: |
103 | case oldconfig: |
|
104 | case silentoldconfig: |
104 | case silentoldconfig: |
|
105 | if (sym_has_value(sym)) { |
105 | if (sym_has_value(sym)) { |
|
106 | printf("%s\n", def); |
106 | printf("%s\n", def); |
|
107 | return 0; |
107 | return 0; |
|
108 | } |
108 | } |
|
109 | check_stdin(); |
109 | check_stdin(); |
|
110 | /* fall through */ |
110 | /* fall through */ |
|
111 | case oldaskconfig: |
111 | case oldaskconfig: |
|
112 | fflush(stdout); |
112 | fflush(stdout); |
|
113 | xfgets(line, sizeof(line), stdin); |
113 | xfgets(line, sizeof(line), stdin); |
|
114 | if (!tty_stdio) |
114 | if (!tty_stdio) |
|
115 | printf("\n"); |
115 | printf("\n"); |
|
116 | return 1; |
116 | return 1; |
|
117 | default: |
117 | default: |
|
118 | break; |
118 | break; |
|
119 | } |
119 | } |
|
120 | |
120 | |
|
121 | switch (type) { |
121 | switch (type) { |
|
122 | case S_INT: |
122 | case S_INT: |
|
123 | case S_HEX: |
123 | case S_HEX: |
|
124 | case S_STRING: |
124 | case S_STRING: |
|
125 | printf("%s\n", def); |
125 | printf("%s\n", def); |
|
126 | return 1; |
126 | return 1; |
|
127 | default: |
127 | default: |
|
128 | ; |
128 | ; |
|
129 | } |
129 | } |
|
130 | printf("%s", line); |
130 | printf("%s", line); |
|
131 | return 1; |
131 | return 1; |
|
132 | } |
132 | } |
|
133 | |
133 | |
|
134 | static int conf_string(struct menu *menu) |
134 | static int conf_string(struct menu *menu) |
|
135 | { |
135 | { |
|
136 | struct symbol *sym = menu->sym; |
136 | struct symbol *sym = menu->sym; |
|
137 | const char *def; |
137 | const char *def; |
|
138 | |
138 | |
|
139 | while (1) { |
139 | while (1) { |
|
140 | printf("%*s%s ", indent - 1, "", _(menu->prompt->text)); |
140 | printf("%*s%s ", indent - 1, "", _(menu->prompt->text)); |
|
141 | printf("(%s) ", sym->name); |
141 | printf("(%s) ", sym->name); |
|
142 | def = sym_get_string_value(sym); |
142 | def = sym_get_string_value(sym); |
|
143 | if (sym_get_string_value(sym)) |
143 | if (sym_get_string_value(sym)) |
|
144 | printf("[%s] ", def); |
144 | printf("[%s] ", def); |
|
145 | if (!conf_askvalue(sym, def)) |
145 | if (!conf_askvalue(sym, def)) |
|
146 | return 0; |
146 | return 0; |
|
147 | switch (line[0]) { |
147 | switch (line[0]) { |
|
148 | case '\n': |
148 | case '\n': |
|
149 | break; |
149 | break; |
|
150 | case '?': |
150 | case '?': |
|
151 | /* print help */ |
151 | /* print help */ |
|
152 | if (line[1] == '\n') { |
152 | if (line[1] == '\n') { |
|
153 | print_help(menu); |
153 | print_help(menu); |
|
154 | def = NULL; |
154 | def = NULL; |
|
155 | break; |
155 | break; |
|
156 | } |
156 | } |
|
157 | /* fall through */ |
157 | /* fall through */ |
|
158 | default: |
158 | default: |
|
159 | line[strlen(line)-1] = 0; |
159 | line[strlen(line)-1] = 0; |
|
160 | def = line; |
160 | def = line; |
|
161 | } |
161 | } |
|
162 | if (def && sym_set_string_value(sym, def)) |
162 | if (def && sym_set_string_value(sym, def)) |
|
163 | return 0; |
163 | return 0; |
|
164 | } |
164 | } |
|
165 | } |
165 | } |
|
166 | |
166 | |
|
167 | static int conf_sym(struct menu *menu) |
167 | static int conf_sym(struct menu *menu) |
|
168 | { |
168 | { |
|
169 | struct symbol *sym = menu->sym; |
169 | struct symbol *sym = menu->sym; |
|
170 | tristate oldval, newval; |
170 | tristate oldval, newval; |
|
171 | |
171 | |
|
172 | while (1) { |
172 | while (1) { |
|
173 | printf("%*s%s ", indent - 1, "", _(menu->prompt->text)); |
173 | printf("%*s%s ", indent - 1, "", _(menu->prompt->text)); |
|
174 | if (sym->name) |
174 | if (sym->name) |
|
175 | printf("(%s) ", sym->name); |
175 | printf("(%s) ", sym->name); |
|
176 | putchar('['); |
176 | putchar('['); |
|
177 | oldval = sym_get_tristate_value(sym); |
177 | oldval = sym_get_tristate_value(sym); |
|
178 | switch (oldval) { |
178 | switch (oldval) { |
|
179 | case no: |
179 | case no: |
|
180 | putchar('N'); |
180 | putchar('N'); |
|
181 | break; |
181 | break; |
|
182 | case mod: |
182 | case mod: |
|
183 | putchar('M'); |
183 | putchar('M'); |
|
184 | break; |
184 | break; |
|
185 | case yes: |
185 | case yes: |
|
186 | putchar('Y'); |
186 | putchar('Y'); |
|
187 | break; |
187 | break; |
|
188 | } |
188 | } |
|
189 | if (oldval != no && sym_tristate_within_range(sym, no)) |
189 | if (oldval != no && sym_tristate_within_range(sym, no)) |
|
190 | printf("/n"); |
190 | printf("/n"); |
|
191 | if (oldval != mod && sym_tristate_within_range(sym, mod)) |
191 | if (oldval != mod && sym_tristate_within_range(sym, mod)) |
|
192 | printf("/m"); |
192 | printf("/m"); |
|
193 | if (oldval != yes && sym_tristate_within_range(sym, yes)) |
193 | if (oldval != yes && sym_tristate_within_range(sym, yes)) |
|
194 | printf("/y"); |
194 | printf("/y"); |
|
195 | if (menu_has_help(menu)) |
195 | if (menu_has_help(menu)) |
|
196 | printf("/?"); |
196 | printf("/?"); |
|
197 | printf("] "); |
197 | printf("] "); |
|
198 | if (!conf_askvalue(sym, sym_get_string_value(sym))) |
198 | if (!conf_askvalue(sym, sym_get_string_value(sym))) |
|
199 | return 0; |
199 | return 0; |
|
200 | strip(line); |
200 | strip(line); |
|
201 | |
201 | |
|
202 | switch (line[0]) { |
202 | switch (line[0]) { |
|
203 | case 'n': |
203 | case 'n': |
|
204 | case 'N': |
204 | case 'N': |
|
205 | newval = no; |
205 | newval = no; |
|
206 | if (!line[1] || !strcmp(&line[1], "o")) |
206 | if (!line[1] || !strcmp(&line[1], "o")) |
|
207 | break; |
207 | break; |
|
208 | continue; |
208 | continue; |
|
209 | case 'm': |
209 | case 'm': |
|
210 | case 'M': |
210 | case 'M': |
|
211 | newval = mod; |
211 | newval = mod; |
|
212 | if (!line[1]) |
212 | if (!line[1]) |
|
213 | break; |
213 | break; |
|
214 | continue; |
214 | continue; |
|
215 | case 'y': |
215 | case 'y': |
|
216 | case 'Y': |
216 | case 'Y': |
|
217 | newval = yes; |
217 | newval = yes; |
|
218 | if (!line[1] || !strcmp(&line[1], "es")) |
218 | if (!line[1] || !strcmp(&line[1], "es")) |
|
219 | break; |
219 | break; |
|
220 | continue; |
220 | continue; |
|
221 | case 0: |
221 | case 0: |
|
222 | newval = oldval; |
222 | newval = oldval; |
|
223 | break; |
223 | break; |
|
224 | case '?': |
224 | case '?': |
|
225 | goto help; |
225 | goto help; |
|
226 | default: |
226 | default: |
|
227 | continue; |
227 | continue; |
|
228 | } |
228 | } |
|
229 | if (sym_set_tristate_value(sym, newval)) |
229 | if (sym_set_tristate_value(sym, newval)) |
|
230 | return 0; |
230 | return 0; |
|
231 | help: |
231 | help: |
|
232 | print_help(menu); |
232 | print_help(menu); |
|
233 | } |
233 | } |
|
234 | } |
234 | } |
|
235 | |
235 | |
|
236 | static int conf_choice(struct menu *menu) |
236 | static int conf_choice(struct menu *menu) |
|
237 | { |
237 | { |
|
238 | struct symbol *sym, *def_sym; |
238 | struct symbol *sym, *def_sym; |
|
239 | struct menu *child; |
239 | struct menu *child; |
|
240 | bool is_new; |
240 | bool is_new; |
|
241 | |
241 | |
|
242 | sym = menu->sym; |
242 | sym = menu->sym; |
|
243 | is_new = !sym_has_value(sym); |
243 | is_new = !sym_has_value(sym); |
|
244 | if (sym_is_changable(sym)) { |
244 | if (sym_is_changable(sym)) { |
|
245 | conf_sym(menu); |
245 | conf_sym(menu); |
|
246 | sym_calc_value(sym); |
246 | sym_calc_value(sym); |
|
247 | switch (sym_get_tristate_value(sym)) { |
247 | switch (sym_get_tristate_value(sym)) { |
|
248 | case no: |
248 | case no: |
|
249 | return 1; |
249 | return 1; |
|
250 | case mod: |
250 | case mod: |
|
251 | return 0; |
251 | return 0; |
|
252 | case yes: |
252 | case yes: |
|
253 | break; |
253 | break; |
|
254 | } |
254 | } |
|
255 | } else { |
255 | } else { |
|
256 | switch (sym_get_tristate_value(sym)) { |
256 | switch (sym_get_tristate_value(sym)) { |
|
257 | case no: |
257 | case no: |
|
258 | return 1; |
258 | return 1; |
|
259 | case mod: |
259 | case mod: |
|
260 | printf("%*s%s\n", indent - 1, "", _(menu_get_prompt(menu))); |
260 | printf("%*s%s\n", indent - 1, "", _(menu_get_prompt(menu))); |
|
261 | return 0; |
261 | return 0; |
|
262 | case yes: |
262 | case yes: |
|
263 | break; |
263 | break; |
|
264 | } |
264 | } |
|
265 | } |
265 | } |
|
266 | |
266 | |
|
267 | while (1) { |
267 | while (1) { |
|
268 | int cnt, def; |
268 | int cnt, def; |
|
269 | |
269 | |
|
270 | printf("%*s%s\n", indent - 1, "", _(menu_get_prompt(menu))); |
270 | printf("%*s%s\n", indent - 1, "", _(menu_get_prompt(menu))); |
|
271 | def_sym = sym_get_choice_value(sym); |
271 | def_sym = sym_get_choice_value(sym); |
|
272 | cnt = def = 0; |
272 | cnt = def = 0; |
|
273 | line[0] = 0; |
273 | line[0] = 0; |
|
274 | for (child = menu->list; child; child = child->next) { |
274 | for (child = menu->list; child; child = child->next) { |
|
275 | if (!menu_is_visible(child)) |
275 | if (!menu_is_visible(child)) |
|
276 | continue; |
276 | continue; |
|
277 | if (!child->sym) { |
277 | if (!child->sym) { |
|
278 | printf("%*c %s\n", indent, '*', _(menu_get_prompt(child))); |
278 | printf("%*c %s\n", indent, '*', _(menu_get_prompt(child))); |
|
279 | continue; |
279 | continue; |
|
280 | } |
280 | } |
|
281 | cnt++; |
281 | cnt++; |
|
282 | if (child->sym == def_sym) { |
282 | if (child->sym == def_sym) { |
|
283 | def = cnt; |
283 | def = cnt; |
|
284 | printf("%*c", indent, '>'); |
284 | printf("%*c", indent, '>'); |
|
285 | } else |
285 | } else |
|
286 | printf("%*c", indent, ' '); |
286 | printf("%*c", indent, ' '); |
|
287 | printf(" %d. %s", cnt, _(menu_get_prompt(child))); |
287 | printf(" %d. %s", cnt, _(menu_get_prompt(child))); |
|
288 | if (child->sym->name) |
288 | if (child->sym->name) |
|
289 | printf(" (%s)", child->sym->name); |
289 | printf(" (%s)", child->sym->name); |
|
290 | if (!sym_has_value(child->sym)) |
290 | if (!sym_has_value(child->sym)) |
|
291 | printf("%s",_(" (NEW)")); |
291 | printf(_(" (NEW)")); |
|
292 | printf("\n"); |
292 | printf("\n"); |
|
293 | } |
293 | } |
|
294 | printf(_("%*schoice"), indent - 1, ""); |
294 | printf(_("%*schoice"), indent - 1, ""); |
|
295 | if (cnt == 1) { |
295 | if (cnt == 1) { |
|
296 | printf("[1]: 1\n"); |
296 | printf("[1]: 1\n"); |
|
297 | goto conf_childs; |
297 | goto conf_childs; |
|
298 | } |
298 | } |
|
299 | printf("[1-%d", cnt); |
299 | printf("[1-%d", cnt); |
|
300 | if (menu_has_help(menu)) |
300 | if (menu_has_help(menu)) |
|
301 | printf("?"); |
301 | printf("?"); |
|
302 | printf("]: "); |
302 | printf("]: "); |
|
303 | switch (input_mode) { |
303 | switch (input_mode) { |
|
304 | case oldconfig: |
304 | case oldconfig: |
|
305 | case silentoldconfig: |
305 | case silentoldconfig: |
|
306 | if (!is_new) { |
306 | if (!is_new) { |
|
307 | cnt = def; |
307 | cnt = def; |
|
308 | printf("%d\n", cnt); |
308 | printf("%d\n", cnt); |
|
309 | break; |
309 | break; |
|
310 | } |
310 | } |
|
311 | check_stdin(); |
311 | check_stdin(); |
|
312 | /* fall through */ |
312 | /* fall through */ |
|
313 | case oldaskconfig: |
313 | case oldaskconfig: |
|
314 | fflush(stdout); |
314 | fflush(stdout); |
|
315 | xfgets(line, sizeof(line), stdin); |
315 | xfgets(line, sizeof(line), stdin); |
|
316 | strip(line); |
316 | strip(line); |
|
317 | if (line[0] == '?') { |
317 | if (line[0] == '?') { |
|
318 | print_help(menu); |
318 | print_help(menu); |
|
319 | continue; |
319 | continue; |
|
320 | } |
320 | } |
|
321 | if (!line[0]) |
321 | if (!line[0]) |
|
322 | cnt = def; |
322 | cnt = def; |
|
323 | else if (isdigit(line[0])) |
323 | else if (isdigit(line[0])) |
|
324 | cnt = atoi(line); |
324 | cnt = atoi(line); |
|
325 | else |
325 | else |
|
326 | continue; |
326 | continue; |
|
327 | break; |
327 | break; |
|
328 | default: |
328 | default: |
|
329 | break; |
329 | break; |
|
330 | } |
330 | } |
|
331 | |
331 | |
|
332 | conf_childs: |
332 | conf_childs: |
|
333 | for (child = menu->list; child; child = child->next) { |
333 | for (child = menu->list; child; child = child->next) { |
|
334 | if (!child->sym || !menu_is_visible(child)) |
334 | if (!child->sym || !menu_is_visible(child)) |
|
335 | continue; |
335 | continue; |
|
336 | if (!--cnt) |
336 | if (!--cnt) |
|
337 | break; |
337 | break; |
|
338 | } |
338 | } |
|
339 | if (!child) |
339 | if (!child) |
|
340 | continue; |
340 | continue; |
|
341 | if (line[0] && line[strlen(line) - 1] == '?') { |
341 | if (line[0] && line[strlen(line) - 1] == '?') { |
|
342 | print_help(child); |
342 | print_help(child); |
|
343 | continue; |
343 | continue; |
|
344 | } |
344 | } |
|
345 | sym_set_choice_value(sym, child->sym); |
345 | sym_set_choice_value(sym, child->sym); |
|
346 | for (child = child->list; child; child = child->next) { |
346 | for (child = child->list; child; child = child->next) { |
|
347 | indent += 2; |
347 | indent += 2; |
|
348 | conf(child); |
348 | conf(child); |
|
349 | indent -= 2; |
349 | indent -= 2; |
|
350 | } |
350 | } |
|
351 | return 1; |
351 | return 1; |
|
352 | } |
352 | } |
|
353 | } |
353 | } |
|
354 | |
354 | |
|
355 | static void conf(struct menu *menu) |
355 | static void conf(struct menu *menu) |
|
356 | { |
356 | { |
|
357 | struct symbol *sym; |
357 | struct symbol *sym; |
|
358 | struct property *prop; |
358 | struct property *prop; |
|
359 | struct menu *child; |
359 | struct menu *child; |
|
360 | |
360 | |
|
361 | if (!menu_is_visible(menu)) |
361 | if (!menu_is_visible(menu)) |
|
362 | return; |
362 | return; |
|
363 | |
363 | |
|
364 | sym = menu->sym; |
364 | sym = menu->sym; |
|
365 | prop = menu->prompt; |
365 | prop = menu->prompt; |
|
366 | if (prop) { |
366 | if (prop) { |
|
367 | const char *prompt; |
367 | const char *prompt; |
|
368 | |
368 | |
|
369 | switch (prop->type) { |
369 | switch (prop->type) { |
|
370 | case P_MENU: |
370 | case P_MENU: |
|
371 | if ((input_mode == silentoldconfig || |
371 | if ((input_mode == silentoldconfig || |
|
372 | input_mode == listnewconfig || |
372 | input_mode == listnewconfig || |
|
373 | input_mode == olddefconfig) && |
373 | input_mode == olddefconfig) && |
|
374 | rootEntry != menu) { |
374 | rootEntry != menu) { |
|
375 | check_conf(menu); |
375 | check_conf(menu); |
|
376 | return; |
376 | return; |
|
377 | } |
377 | } |
|
378 | /* fall through */ |
378 | /* fall through */ |
|
379 | case P_COMMENT: |
379 | case P_COMMENT: |
|
380 | prompt = menu_get_prompt(menu); |
380 | prompt = menu_get_prompt(menu); |
|
381 | if (prompt) |
381 | if (prompt) |
|
382 | printf("%*c\n%*c %s\n%*c\n", |
382 | printf("%*c\n%*c %s\n%*c\n", |
|
383 | indent, '*', |
383 | indent, '*', |
|
384 | indent, '*', _(prompt), |
384 | indent, '*', _(prompt), |
|
385 | indent, '*'); |
385 | indent, '*'); |
|
386 | default: |
386 | default: |
|
387 | ; |
387 | ; |
|
388 | } |
388 | } |
|
389 | } |
389 | } |
|
390 | |
390 | |
|
391 | if (!sym) |
391 | if (!sym) |
|
392 | goto conf_childs; |
392 | goto conf_childs; |
|
393 | |
393 | |
|
394 | if (sym_is_choice(sym)) { |
394 | if (sym_is_choice(sym)) { |
|
395 | conf_choice(menu); |
395 | conf_choice(menu); |
|
396 | if (sym->curr.tri != mod) |
396 | if (sym->curr.tri != mod) |
|
397 | return; |
397 | return; |
|
398 | goto conf_childs; |
398 | goto conf_childs; |
|
399 | } |
399 | } |
|
400 | |
400 | |
|
401 | switch (sym->type) { |
401 | switch (sym->type) { |
|
402 | case S_INT: |
402 | case S_INT: |
|
403 | case S_HEX: |
403 | case S_HEX: |
|
404 | case S_STRING: |
404 | case S_STRING: |
|
405 | conf_string(menu); |
405 | conf_string(menu); |
|
406 | break; |
406 | break; |
|
407 | default: |
407 | default: |
|
408 | conf_sym(menu); |
408 | conf_sym(menu); |
|
409 | break; |
409 | break; |
|
410 | } |
410 | } |
|
411 | |
411 | |
|
412 | conf_childs: |
412 | conf_childs: |
|
413 | if (sym) |
413 | if (sym) |
|
414 | indent += 2; |
414 | indent += 2; |
|
415 | for (child = menu->list; child; child = child->next) |
415 | for (child = menu->list; child; child = child->next) |
|
416 | conf(child); |
416 | conf(child); |
|
417 | if (sym) |
417 | if (sym) |
|
418 | indent -= 2; |
418 | indent -= 2; |
|
419 | } |
419 | } |
|
420 | |
420 | |
|
421 | static void check_conf(struct menu *menu) |
421 | static void check_conf(struct menu *menu) |
|
422 | { |
422 | { |
|
423 | struct symbol *sym; |
423 | struct symbol *sym; |
|
424 | struct menu *child; |
424 | struct menu *child; |
|
425 | |
425 | |
|
426 | if (!menu_is_visible(menu)) |
426 | if (!menu_is_visible(menu)) |
|
427 | return; |
427 | return; |
|
428 | |
428 | |
|
429 | sym = menu->sym; |
429 | sym = menu->sym; |
|
430 | if (sym && !sym_has_value(sym)) { |
430 | if (sym && !sym_has_value(sym)) { |
|
431 | if (sym_is_changable(sym) || |
431 | if (sym_is_changable(sym) || |
|
432 | (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes)) { |
432 | (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes)) { |
|
433 | if (input_mode == listnewconfig) { |
433 | if (input_mode == listnewconfig) { |
|
434 | if (sym->name && !sym_is_choice_value(sym)) { |
434 | if (sym->name && !sym_is_choice_value(sym)) { |
|
435 | printf("%s%s\n", CONFIG_, sym->name); |
435 | printf("%s%s\n", CONFIG_, sym->name); |
|
436 | } |
436 | } |
|
437 | } else if (input_mode != olddefconfig) { |
437 | } else if (input_mode != olddefconfig) { |
|
438 | if (!conf_cnt++) |
438 | if (!conf_cnt++) |
|
439 | printf("%s",_("*\n* Restart config...\n*\n")); |
439 | printf(_("*\n* Restart config...\n*\n")); |
|
440 | rootEntry = menu_get_parent_menu(menu); |
440 | rootEntry = menu_get_parent_menu(menu); |
|
441 | conf(rootEntry); |
441 | conf(rootEntry); |
|
442 | } |
442 | } |
|
443 | } |
443 | } |
|
444 | } |
444 | } |
|
445 | |
445 | |
|
446 | for (child = menu->list; child; child = child->next) |
446 | for (child = menu->list; child; child = child->next) |
|
447 | check_conf(child); |
447 | check_conf(child); |
|
448 | } |
448 | } |
|
449 | |
449 | |
|
450 | static struct option long_opts[] = { |
450 | static struct option long_opts[] = { |
|
451 | {"oldaskconfig", no_argument, NULL, oldaskconfig}, |
451 | {"oldaskconfig", no_argument, NULL, oldaskconfig}, |
|
452 | {"oldconfig", no_argument, NULL, oldconfig}, |
452 | {"oldconfig", no_argument, NULL, oldconfig}, |
|
453 | {"silentoldconfig", no_argument, NULL, silentoldconfig}, |
453 | {"silentoldconfig", no_argument, NULL, silentoldconfig}, |
|
454 | {"defconfig", optional_argument, NULL, defconfig}, |
454 | {"defconfig", optional_argument, NULL, defconfig}, |
|
455 | {"savedefconfig", required_argument, NULL, savedefconfig}, |
455 | {"savedefconfig", required_argument, NULL, savedefconfig}, |
|
456 | {"allnoconfig", no_argument, NULL, allnoconfig}, |
456 | {"allnoconfig", no_argument, NULL, allnoconfig}, |
|
457 | {"allyesconfig", no_argument, NULL, allyesconfig}, |
457 | {"allyesconfig", no_argument, NULL, allyesconfig}, |
|
458 | {"allmodconfig", no_argument, NULL, allmodconfig}, |
458 | {"allmodconfig", no_argument, NULL, allmodconfig}, |
|
459 | {"alldefconfig", no_argument, NULL, alldefconfig}, |
459 | {"alldefconfig", no_argument, NULL, alldefconfig}, |
|
460 | {"randconfig", no_argument, NULL, randconfig}, |
460 | {"randconfig", no_argument, NULL, randconfig}, |
|
461 | {"listnewconfig", no_argument, NULL, listnewconfig}, |
461 | {"listnewconfig", no_argument, NULL, listnewconfig}, |
|
462 | {"olddefconfig", no_argument, NULL, olddefconfig}, |
462 | {"olddefconfig", no_argument, NULL, olddefconfig}, |
|
463 | /* |
463 | /* |
|
464 | * oldnoconfig is an alias of olddefconfig, because people already |
464 | * oldnoconfig is an alias of olddefconfig, because people already |
|
465 | * are dependent on its behavior(sets new symbols to their default |
465 | * are dependent on its behavior(sets new symbols to their default |
|
466 | * value but not 'n') with the counter-intuitive name. |
466 | * value but not 'n') with the counter-intuitive name. |
|
467 | */ |
467 | */ |
|
468 | {"oldnoconfig", no_argument, NULL, olddefconfig}, |
468 | {"oldnoconfig", no_argument, NULL, olddefconfig}, |
|
469 | {NULL, 0, NULL, 0} |
469 | {NULL, 0, NULL, 0} |
|
470 | }; |
470 | }; |
|
471 | |
471 | |
|
472 | static void conf_usage(const char *progname) |
472 | static void conf_usage(const char *progname) |
|
473 | { |
473 | { |
|
474 | |
474 | |
|
475 | printf("Usage: %s [-s] [option] <kconfig-file>\n", progname); |
475 | printf("Usage: %s [-s] [option] <kconfig-file>\n", progname); |
|
476 | printf("[option] is _one_ of the following:\n"); |
476 | printf("[option] is _one_ of the following:\n"); |
|
477 | printf(" --listnewconfig List new options\n"); |
477 | printf(" --listnewconfig List new options\n"); |
|
478 | printf(" --oldaskconfig Start a new configuration using a line-oriented program\n"); |
478 | printf(" --oldaskconfig Start a new configuration using a line-oriented program\n"); |
|
479 | printf(" --oldconfig Update a configuration using a provided .config as base\n"); |
479 | printf(" --oldconfig Update a configuration using a provided .config as base\n"); |
|
480 | printf(" --silentoldconfig Same as oldconfig, but quietly, additionally update deps\n"); |
480 | printf(" --silentoldconfig Same as oldconfig, but quietly, additionally update deps\n"); |
|
481 | printf(" --olddefconfig Same as silentoldconfig but sets new symbols to their default value\n"); |
481 | printf(" --olddefconfig Same as silentoldconfig but sets new symbols to their default value\n"); |
|
482 | printf(" --oldnoconfig An alias of olddefconfig\n"); |
482 | printf(" --oldnoconfig An alias of olddefconfig\n"); |
|
483 | printf(" --defconfig <file> New config with default defined in <file>\n"); |
483 | printf(" --defconfig <file> New config with default defined in <file>\n"); |
|
484 | printf(" --savedefconfig <file> Save the minimal current configuration to <file>\n"); |
484 | printf(" --savedefconfig <file> Save the minimal current configuration to <file>\n"); |
|
485 | printf(" --allnoconfig New config where all options are answered with no\n"); |
485 | printf(" --allnoconfig New config where all options are answered with no\n"); |
|
486 | printf(" --allyesconfig New config where all options are answered with yes\n"); |
486 | printf(" --allyesconfig New config where all options are answered with yes\n"); |
|
487 | printf(" --allmodconfig New config where all options are answered with mod\n"); |
487 | printf(" --allmodconfig New config where all options are answered with mod\n"); |
|
488 | printf(" --alldefconfig New config with all symbols set to default\n"); |
488 | printf(" --alldefconfig New config with all symbols set to default\n"); |
|
489 | printf(" --randconfig New config with random answer to all options\n"); |
489 | printf(" --randconfig New config with random answer to all options\n"); |
|
490 | } |
490 | } |
|
491 | |
491 | |
|
492 | int main(int ac, char **av) |
492 | int main(int ac, char **av) |
|
493 | { |
493 | { |
|
494 | const char *progname = av[0]; |
494 | const char *progname = av[0]; |
|
495 | int opt; |
495 | int opt; |
|
496 | const char *name, *defconfig_file = NULL /* gcc uninit */; |
496 | const char *name, *defconfig_file = NULL /* gcc uninit */; |
|
497 | struct stat tmpstat; |
497 | struct stat tmpstat; |
|
498 | const char *input_file = NULL, *output_file = NULL; |
498 | const char *input_file = NULL, *output_file = NULL; |
|
499 | |
499 | |
|
500 | setlocale(LC_ALL, ""); |
500 | setlocale(LC_ALL, ""); |
|
501 | bindtextdomain(PACKAGE, LOCALEDIR); |
501 | bindtextdomain(PACKAGE, LOCALEDIR); |
|
502 | textdomain(PACKAGE); |
502 | textdomain(PACKAGE); |
|
503 | |
503 | |
|
504 | tty_stdio = isatty(0) && isatty(1) && isatty(2); |
504 | tty_stdio = isatty(0) && isatty(1) && isatty(2); |
|
505 | |
505 | |
|
506 | while ((opt = getopt_long(ac, av, "r:w:s", long_opts, NULL)) != -1) { |
506 | while ((opt = getopt_long(ac, av, "r:w:s", long_opts, NULL)) != -1) { |
|
507 | if (opt == 's') { |
507 | if (opt == 's') { |
|
508 | conf_set_message_callback(NULL); |
508 | conf_set_message_callback(NULL); |
|
509 | continue; |
509 | continue; |
|
510 | } |
510 | } |
|
511 | switch (opt) { |
511 | switch (opt) { |
|
512 | case silentoldconfig: |
512 | case silentoldconfig: |
|
513 | sync_kconfig = 1; |
513 | sync_kconfig = 1; |
|
514 | break; |
514 | break; |
|
515 | case defconfig: |
515 | case defconfig: |
|
516 | case savedefconfig: |
516 | case savedefconfig: |
|
517 | defconfig_file = optarg; |
517 | defconfig_file = optarg; |
|
518 | break; |
518 | break; |
|
519 | case randconfig: |
519 | case randconfig: |
|
520 | { |
520 | { |
|
521 | struct timeval now; |
521 | struct timeval now; |
|
522 | unsigned int seed; |
522 | unsigned int seed; |
|
523 | char *seed_env; |
523 | char *seed_env; |
|
524 | |
524 | |
|
525 | /* |
525 | /* |
|
526 | * Use microseconds derived seed, |
526 | * Use microseconds derived seed, |
|
527 | * compensate for systems where it may be zero |
527 | * compensate for systems where it may be zero |
|
528 | */ |
528 | */ |
|
529 | gettimeofday(&now, NULL); |
529 | gettimeofday(&now, NULL); |
|
530 | seed = (unsigned int)((now.tv_sec + 1) * (now.tv_usec + 1)); |
530 | seed = (unsigned int)((now.tv_sec + 1) * (now.tv_usec + 1)); |
|
531 | |
531 | |
|
532 | seed_env = getenv("KCONFIG_SEED"); |
532 | seed_env = getenv("KCONFIG_SEED"); |
|
533 | if( seed_env && *seed_env ) { |
533 | if( seed_env && *seed_env ) { |
|
534 | char *endp; |
534 | char *endp; |
|
535 | int tmp = (int)strtol(seed_env, &endp, 0); |
535 | int tmp = (int)strtol(seed_env, &endp, 0); |
|
536 | if (*endp == '\0') { |
536 | if (*endp == '\0') { |
|
537 | seed = tmp; |
537 | seed = tmp; |
|
538 | } |
538 | } |
|
539 | } |
539 | } |
|
540 | fprintf( stderr, "KCONFIG_SEED=0x%X\n", seed ); |
540 | fprintf( stderr, "KCONFIG_SEED=0x%X\n", seed ); |
|
541 | srand(seed); |
541 | srand(seed); |
|
542 | break; |
542 | break; |
|
543 | } |
543 | } |
|
544 | case oldaskconfig: |
544 | case oldaskconfig: |
|
545 | case oldconfig: |
545 | case oldconfig: |
|
546 | case allnoconfig: |
546 | case allnoconfig: |
|
547 | case allyesconfig: |
547 | case allyesconfig: |
|
548 | case allmodconfig: |
548 | case allmodconfig: |
|
549 | case alldefconfig: |
549 | case alldefconfig: |
|
550 | case listnewconfig: |
550 | case listnewconfig: |
|
551 | case olddefconfig: |
551 | case olddefconfig: |
|
552 | break; |
552 | break; |
|
553 | case 'r': |
553 | case 'r': |
|
554 | input_file = optarg; |
554 | input_file = optarg; |
|
555 | continue; |
555 | continue; |
|
556 | case 'w': |
556 | case 'w': |
|
557 | output_file = optarg; |
557 | output_file = optarg; |
|
558 | continue; |
558 | continue; |
|
559 | case '?': |
559 | case '?': |
|
560 | conf_usage(progname); |
560 | conf_usage(progname); |
|
561 | exit(1); |
561 | exit(1); |
|
562 | break; |
562 | break; |
|
563 | } |
563 | } |
|
564 | input_mode = (enum input_mode)opt; |
564 | input_mode = (enum input_mode)opt; |
|
565 | } |
565 | } |
|
566 | if (ac == optind) { |
566 | if (ac == optind) { |
|
567 | printf(_("%s: Kconfig file missing\n"), av[0]); |
567 | printf(_("%s: Kconfig file missing\n"), av[0]); |
|
568 | conf_usage(progname); |
568 | conf_usage(progname); |
|
569 | exit(1); |
569 | exit(1); |
|
570 | } |
570 | } |
|
571 | name = av[optind]; |
571 | name = av[optind]; |
|
572 | conf_parse(name); |
572 | conf_parse(name); |
|
573 | //zconfdump(stdout); |
573 | //zconfdump(stdout); |
|
574 | if (sync_kconfig) { |
574 | if (sync_kconfig) { |
|
575 | name = conf_get_configname(); |
575 | name = conf_get_configname(); |
|
576 | if (stat(name, &tmpstat)) { |
576 | if (stat(name, &tmpstat)) { |
|
577 | fprintf(stderr, _("***\n" |
577 | fprintf(stderr, _("***\n" |
|
578 | "*** Configuration file \"%s\" not found!\n" |
578 | "*** Configuration file \"%s\" not found!\n" |
|
579 | "***\n" |
579 | "***\n" |
|
580 | "*** Please run some configurator (e.g. \"make oldconfig\" or\n" |
580 | "*** Please run some configurator (e.g. \"make oldconfig\" or\n" |
|
581 | "*** \"make menuconfig\" or \"make xconfig\").\n" |
581 | "*** \"make menuconfig\" or \"make xconfig\").\n" |
|
582 | "***\n"), name); |
582 | "***\n"), name); |
|
583 | exit(1); |
583 | exit(1); |
|
584 | } |
584 | } |
|
585 | } |
585 | } |
|
586 | |
586 | |
|
587 | switch (input_mode) { |
587 | switch (input_mode) { |
|
588 | case defconfig: |
588 | case defconfig: |
|
589 | if (!defconfig_file) |
589 | if (!defconfig_file) |
|
590 | defconfig_file = conf_get_default_confname(); |
590 | defconfig_file = conf_get_default_confname(); |
|
591 | if (conf_read(defconfig_file)) { |
591 | if (conf_read(defconfig_file)) { |
|
592 | printf(_("***\n" |
592 | printf(_("***\n" |
|
593 | "*** Can't find default configuration \"%s\"!\n" |
593 | "*** Can't find default configuration \"%s\"!\n" |
|
594 | "***\n"), defconfig_file); |
594 | "***\n"), defconfig_file); |
|
595 | exit(1); |
595 | exit(1); |
|
596 | } |
596 | } |
|
597 | break; |
597 | break; |
|
598 | case savedefconfig: |
598 | case savedefconfig: |
|
599 | case silentoldconfig: |
599 | case silentoldconfig: |
|
600 | case oldaskconfig: |
600 | case oldaskconfig: |
|
601 | case oldconfig: |
601 | case oldconfig: |
|
602 | case listnewconfig: |
602 | case listnewconfig: |
|
603 | case olddefconfig: |
603 | case olddefconfig: |
|
604 | case allnoconfig: |
604 | case allnoconfig: |
|
605 | case allyesconfig: |
605 | case allyesconfig: |
|
606 | case allmodconfig: |
606 | case allmodconfig: |
|
607 | case alldefconfig: |
607 | case alldefconfig: |
|
608 | case randconfig: |
608 | case randconfig: |
|
609 | conf_read(input_file); |
609 | conf_read(input_file); |
|
610 | break; |
610 | break; |
|
611 | default: |
611 | default: |
|
612 | break; |
612 | break; |
|
613 | } |
613 | } |
|
614 | |
614 | |
|
615 | if (sync_kconfig) { |
615 | if (sync_kconfig) { |
|
616 | if (conf_get_changed()) { |
616 | if (conf_get_changed()) { |
|
617 | name = getenv("KCONFIG_NOSILENTUPDATE"); |
617 | name = getenv("KCONFIG_NOSILENTUPDATE"); |
|
618 | if (name && *name) { |
618 | if (name && *name) { |
|
619 | fprintf(stderr, |
619 | fprintf(stderr, |
|
620 | _("\n*** The configuration requires explicit update.\n\n")); |
620 | _("\n*** The configuration requires explicit update.\n\n")); |
|
621 | return 1; |
621 | return 1; |
|
622 | } |
622 | } |
|
623 | } |
623 | } |
|
624 | valid_stdin = tty_stdio; |
624 | valid_stdin = tty_stdio; |
|
625 | } |
625 | } |
|
626 | |
626 | |
|
627 | switch (input_mode) { |
627 | switch (input_mode) { |
|
628 | case allnoconfig: |
628 | case allnoconfig: |
|
629 | conf_set_all_new_symbols(def_no); |
629 | conf_set_all_new_symbols(def_no); |
|
630 | break; |
630 | break; |
|
631 | case allyesconfig: |
631 | case allyesconfig: |
|
632 | conf_set_all_new_symbols(def_yes); |
632 | conf_set_all_new_symbols(def_yes); |
|
633 | break; |
633 | break; |
|
634 | case allmodconfig: |
634 | case allmodconfig: |
|
635 | conf_set_all_new_symbols(def_mod); |
635 | conf_set_all_new_symbols(def_mod); |
|
636 | break; |
636 | break; |
|
637 | case alldefconfig: |
637 | case alldefconfig: |
|
638 | conf_set_all_new_symbols(def_default); |
638 | conf_set_all_new_symbols(def_default); |
|
639 | break; |
639 | break; |
|
640 | case randconfig: |
640 | case randconfig: |
|
641 | /* Really nothing to do in this loop */ |
641 | /* Really nothing to do in this loop */ |
|
642 | while (conf_set_all_new_symbols(def_random)) ; |
642 | while (conf_set_all_new_symbols(def_random)) ; |
|
643 | break; |
643 | break; |
|
644 | case defconfig: |
644 | case defconfig: |
|
645 | conf_set_all_new_symbols(def_default); |
645 | conf_set_all_new_symbols(def_default); |
|
646 | break; |
646 | break; |
|
647 | case savedefconfig: |
647 | case savedefconfig: |
|
648 | break; |
648 | break; |
|
649 | case oldaskconfig: |
649 | case oldaskconfig: |
|
650 | rootEntry = &rootmenu; |
650 | rootEntry = &rootmenu; |
|
651 | conf(&rootmenu); |
651 | conf(&rootmenu); |
|
652 | input_mode = silentoldconfig; |
652 | input_mode = silentoldconfig; |
|
653 | /* fall through */ |
653 | /* fall through */ |
|
654 | case oldconfig: |
654 | case oldconfig: |
|
655 | case listnewconfig: |
655 | case listnewconfig: |
|
656 | case olddefconfig: |
656 | case olddefconfig: |
|
657 | case silentoldconfig: |
657 | case silentoldconfig: |
|
658 | /* Update until a loop caused no more changes */ |
658 | /* Update until a loop caused no more changes */ |
|
659 | do { |
659 | do { |
|
660 | conf_cnt = 0; |
660 | conf_cnt = 0; |
|
661 | check_conf(&rootmenu); |
661 | check_conf(&rootmenu); |
|
662 | } while (conf_cnt && |
662 | } while (conf_cnt && |
|
663 | (input_mode != listnewconfig && |
663 | (input_mode != listnewconfig && |
|
664 | input_mode != olddefconfig)); |
664 | input_mode != olddefconfig)); |
|
665 | break; |
665 | break; |
|
666 | } |
666 | } |
|
667 | |
667 | |
|
668 | if (sync_kconfig) { |
668 | if (sync_kconfig) { |
|
669 | /* silentoldconfig is used during the build so we shall update autoconf. |
669 | /* silentoldconfig is used during the build so we shall update autoconf. |
|
670 | * All other commands are only used to generate a config. |
670 | * All other commands are only used to generate a config. |
|
671 | */ |
671 | */ |
|
672 | if ((output_file || conf_get_changed()) && |
672 | if ((output_file || conf_get_changed()) && |
|
673 | conf_write(output_file)) { |
673 | conf_write(output_file)) { |
|
674 | fprintf(stderr, _("\n*** Error during writing of the configuration.\n\n")); |
674 | fprintf(stderr, _("\n*** Error during writing of the configuration.\n\n")); |
|
675 | exit(1); |
675 | exit(1); |
|
676 | } |
676 | } |
|
677 | if (conf_write_autoconf()) { |
677 | if (conf_write_autoconf()) { |
|
678 | fprintf(stderr, _("\n*** Error during update of the configuration.\n\n")); |
678 | fprintf(stderr, _("\n*** Error during update of the configuration.\n\n")); |
|
679 | return 1; |
679 | return 1; |
|
680 | } |
680 | } |
|
681 | } else if (input_mode == savedefconfig) { |
681 | } else if (input_mode == savedefconfig) { |
|
682 | if (conf_write_defconfig(defconfig_file)) { |
682 | if (conf_write_defconfig(defconfig_file)) { |
|
683 | fprintf(stderr, _("n*** Error while saving defconfig to: %s\n\n"), |
683 | fprintf(stderr, _("n*** Error while saving defconfig to: %s\n\n"), |
|
684 | defconfig_file); |
684 | defconfig_file); |
|
685 | return 1; |
685 | return 1; |
|
686 | } |
686 | } |
|
687 | } else if (input_mode != listnewconfig) { |
687 | } else if (input_mode != listnewconfig) { |
|
688 | if (conf_write(output_file)) { |
688 | if (conf_write(output_file)) { |
|
689 | fprintf(stderr, _("\n*** Error during writing of the configuration.\n\n")); |
689 | fprintf(stderr, _("\n*** Error during writing of the configuration.\n\n")); |
|
690 | exit(1); |
690 | exit(1); |
|
691 | } |
691 | } |
|
692 | } |
692 | } |
|
693 | return 0; |
693 | return 0; |
|
694 | } |
694 | } |
|
695 | |
695 | |
|
696 | /* |
696 | /* |
|
697 | * Helper function to facilitate fgets() by Jean Sacren. |
697 | * Helper function to facilitate fgets() by Jean Sacren. |
|
698 | */ |
698 | */ |
|
699 | void xfgets(char *str, int size, FILE *in) |
699 | void xfgets(char *str, int size, FILE *in) |
|
700 | { |
700 | { |
|
701 | if (fgets(str, size, in) == NULL) |
701 | if (fgets(str, size, in) == NULL) |
|
702 | fprintf(stderr, "\nError in reading or end of file.\n"); |
702 | fprintf(stderr, "\nError in reading or end of file.\n"); |
|
703 | } |
703 | } |
|
704 | |
704 | |