confdata.c 26 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282
  1. /*
  2. * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  3. * Released under the terms of the GNU GPL v2.0.
  4. */
  5. #include <sys/stat.h>
  6. #include <ctype.h>
  7. #include <errno.h>
  8. #include <fcntl.h>
  9. #include <stdarg.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <time.h>
  14. #include <unistd.h>
  15. #include <libgen.h>
  16. #include "lkc.h"
  17. struct conf_printer {
  18. void (*print_symbol)(FILE *, struct symbol *, const char *, void *);
  19. void (*print_comment)(FILE *, const char *, void *);
  20. };
  21. static void conf_warning(const char *fmt, ...)
  22. __attribute__ ((format (printf, 1, 2)));
  23. static void conf_message(const char *fmt, ...)
  24. __attribute__ ((format (printf, 1, 2)));
  25. static const char *conf_filename;
  26. static int conf_lineno, conf_warnings;
  27. const char conf_defname[] = ".defconfig";
  28. static void conf_warning(const char *fmt, ...)
  29. {
  30. va_list ap;
  31. va_start(ap, fmt);
  32. fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
  33. vfprintf(stderr, fmt, ap);
  34. fprintf(stderr, "\n");
  35. va_end(ap);
  36. conf_warnings++;
  37. }
  38. static void conf_default_message_callback(const char *fmt, va_list ap)
  39. {
  40. printf("#\n# ");
  41. vprintf(fmt, ap);
  42. printf("\n#\n");
  43. }
  44. static void (*conf_message_callback) (const char *fmt, va_list ap) =
  45. conf_default_message_callback;
  46. void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap))
  47. {
  48. conf_message_callback = fn;
  49. }
  50. static void conf_message(const char *fmt, ...)
  51. {
  52. va_list ap;
  53. va_start(ap, fmt);
  54. if (conf_message_callback)
  55. conf_message_callback(fmt, ap);
  56. va_end(ap);
  57. }
  58. const char *conf_get_configname(void)
  59. {
  60. char *name = getenv("BR2_CONFIG");
  61. return name ? name : ".config";
  62. }
  63. const char *conf_get_autoconfig_name(void)
  64. {
  65. return getenv("KCONFIG_AUTOCONFIG");
  66. }
  67. static char *conf_expand_value(const char *in)
  68. {
  69. struct symbol *sym;
  70. const char *src;
  71. static char res_value[SYMBOL_MAXLENGTH];
  72. char *dst, name[SYMBOL_MAXLENGTH];
  73. res_value[0] = 0;
  74. dst = name;
  75. while ((src = strchr(in, '$'))) {
  76. strncat(res_value, in, src - in);
  77. src++;
  78. dst = name;
  79. while (isalnum(*src) || *src == '_')
  80. *dst++ = *src++;
  81. *dst = 0;
  82. sym = sym_lookup(name, 0);
  83. sym_calc_value(sym);
  84. strcat(res_value, sym_get_string_value(sym));
  85. in = src;
  86. }
  87. strcat(res_value, in);
  88. return res_value;
  89. }
  90. char *conf_get_default_confname(void)
  91. {
  92. struct stat buf;
  93. static char fullname[PATH_MAX+1];
  94. char *env, *name;
  95. name = conf_expand_value(conf_defname);
  96. env = getenv(SRCTREE);
  97. if (env) {
  98. sprintf(fullname, "%s/%s", env, name);
  99. if (!stat(fullname, &buf))
  100. return fullname;
  101. }
  102. return name;
  103. }
  104. static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
  105. {
  106. char *p2;
  107. switch (sym->type) {
  108. case S_TRISTATE:
  109. if (p[0] == 'm') {
  110. sym->def[def].tri = mod;
  111. sym->flags |= def_flags;
  112. break;
  113. }
  114. /* fall through */
  115. case S_BOOLEAN:
  116. if (p[0] == 'y') {
  117. sym->def[def].tri = yes;
  118. sym->flags |= def_flags;
  119. break;
  120. }
  121. if (p[0] == 'n') {
  122. sym->def[def].tri = no;
  123. sym->flags |= def_flags;
  124. break;
  125. }
  126. if (def != S_DEF_AUTO)
  127. conf_warning("symbol value '%s' invalid for %s",
  128. p, sym->name);
  129. return 1;
  130. case S_OTHER:
  131. if (*p != '"') {
  132. for (p2 = p; *p2 && !isspace(*p2); p2++)
  133. ;
  134. sym->type = S_STRING;
  135. goto done;
  136. }
  137. /* fall through */
  138. case S_STRING:
  139. if (*p++ != '"')
  140. break;
  141. for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
  142. if (*p2 == '"') {
  143. *p2 = 0;
  144. break;
  145. }
  146. memmove(p2, p2 + 1, strlen(p2));
  147. }
  148. if (!p2) {
  149. if (def != S_DEF_AUTO)
  150. conf_warning("invalid string found");
  151. return 1;
  152. }
  153. /* fall through */
  154. case S_INT:
  155. case S_HEX:
  156. done:
  157. if (sym_string_valid(sym, p)) {
  158. sym->def[def].val = xstrdup(p);
  159. sym->flags |= def_flags;
  160. } else {
  161. if (def != S_DEF_AUTO)
  162. conf_warning("symbol value '%s' invalid for %s",
  163. p, sym->name);
  164. return 1;
  165. }
  166. break;
  167. default:
  168. ;
  169. }
  170. return 0;
  171. }
  172. #define LINE_GROWTH 16
  173. static int add_byte(int c, char **lineptr, size_t slen, size_t *n)
  174. {
  175. char *nline;
  176. size_t new_size = slen + 1;
  177. if (new_size > *n) {
  178. new_size += LINE_GROWTH - 1;
  179. new_size *= 2;
  180. nline = xrealloc(*lineptr, new_size);
  181. if (!nline)
  182. return -1;
  183. *lineptr = nline;
  184. *n = new_size;
  185. }
  186. (*lineptr)[slen] = c;
  187. return 0;
  188. }
  189. static ssize_t compat_getline(char **lineptr, size_t *n, FILE *stream)
  190. {
  191. char *line = *lineptr;
  192. size_t slen = 0;
  193. for (;;) {
  194. int c = getc(stream);
  195. switch (c) {
  196. case '\n':
  197. if (add_byte(c, &line, slen, n) < 0)
  198. goto e_out;
  199. slen++;
  200. /* fall through */
  201. case EOF:
  202. if (add_byte('\0', &line, slen, n) < 0)
  203. goto e_out;
  204. *lineptr = line;
  205. if (slen == 0)
  206. return -1;
  207. return slen;
  208. default:
  209. if (add_byte(c, &line, slen, n) < 0)
  210. goto e_out;
  211. slen++;
  212. }
  213. }
  214. e_out:
  215. line[slen-1] = '\0';
  216. *lineptr = line;
  217. return -1;
  218. }
  219. int conf_read_simple(const char *name, int def)
  220. {
  221. FILE *in = NULL;
  222. char *line = NULL;
  223. size_t line_asize = 0;
  224. char *p, *p2;
  225. struct symbol *sym;
  226. int i, def_flags;
  227. if (name) {
  228. in = zconf_fopen(name);
  229. } else {
  230. struct property *prop;
  231. name = conf_get_configname();
  232. in = zconf_fopen(name);
  233. if (in)
  234. goto load;
  235. sym_add_change_count(1);
  236. if (!sym_defconfig_list)
  237. return 1;
  238. for_all_defaults(sym_defconfig_list, prop) {
  239. if (expr_calc_value(prop->visible.expr) == no ||
  240. prop->expr->type != E_SYMBOL)
  241. continue;
  242. name = conf_expand_value(prop->expr->left.sym->name);
  243. in = zconf_fopen(name);
  244. if (in) {
  245. conf_message(_("using defaults found in %s"),
  246. name);
  247. goto load;
  248. }
  249. }
  250. }
  251. if (!in)
  252. return 1;
  253. load:
  254. conf_filename = name;
  255. conf_lineno = 0;
  256. conf_warnings = 0;
  257. def_flags = SYMBOL_DEF << def;
  258. for_all_symbols(i, sym) {
  259. sym->flags |= SYMBOL_CHANGED;
  260. sym->flags &= ~(def_flags|SYMBOL_VALID);
  261. if (sym_is_choice(sym))
  262. sym->flags |= def_flags;
  263. switch (sym->type) {
  264. case S_INT:
  265. case S_HEX:
  266. case S_STRING:
  267. if (sym->def[def].val)
  268. free(sym->def[def].val);
  269. /* fall through */
  270. default:
  271. sym->def[def].val = NULL;
  272. sym->def[def].tri = no;
  273. }
  274. }
  275. while (compat_getline(&line, &line_asize, in) != -1) {
  276. conf_lineno++;
  277. sym = NULL;
  278. if (line[0] == '#') {
  279. if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))
  280. continue;
  281. p = strchr(line + 2 + strlen(CONFIG_), ' ');
  282. if (!p)
  283. continue;
  284. *p++ = 0;
  285. if (strncmp(p, "is not set", 10))
  286. continue;
  287. if (def == S_DEF_USER) {
  288. sym = sym_find(line + 2 + strlen(CONFIG_));
  289. if (!sym) {
  290. sym_add_change_count(1);
  291. goto setsym;
  292. }
  293. } else {
  294. sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);
  295. if (sym->type == S_UNKNOWN)
  296. sym->type = S_BOOLEAN;
  297. }
  298. if (sym->flags & def_flags) {
  299. conf_warning("override: reassigning to symbol %s", sym->name);
  300. }
  301. switch (sym->type) {
  302. case S_BOOLEAN:
  303. case S_TRISTATE:
  304. sym->def[def].tri = no;
  305. sym->flags |= def_flags;
  306. break;
  307. default:
  308. ;
  309. }
  310. } else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {
  311. p = strchr(line + strlen(CONFIG_), '=');
  312. if (!p)
  313. continue;
  314. *p++ = 0;
  315. p2 = strchr(p, '\n');
  316. if (p2) {
  317. *p2-- = 0;
  318. if (*p2 == '\r')
  319. *p2 = 0;
  320. }
  321. if (def == S_DEF_USER) {
  322. sym = sym_find(line + strlen(CONFIG_));
  323. if (!sym) {
  324. sym_add_change_count(1);
  325. goto setsym;
  326. }
  327. } else {
  328. sym = sym_lookup(line + strlen(CONFIG_), 0);
  329. if (sym->type == S_UNKNOWN)
  330. sym->type = S_OTHER;
  331. }
  332. if (sym->flags & def_flags) {
  333. conf_warning("override: reassigning to symbol %s", sym->name);
  334. }
  335. if (conf_set_sym_val(sym, def, def_flags, p))
  336. continue;
  337. } else {
  338. if (line[0] != '\r' && line[0] != '\n')
  339. conf_warning("unexpected data: %.*s",
  340. (int)strcspn(line, "\r\n"), line);
  341. continue;
  342. }
  343. setsym:
  344. if (sym && sym_is_choice_value(sym)) {
  345. struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
  346. switch (sym->def[def].tri) {
  347. case no:
  348. break;
  349. case mod:
  350. if (cs->def[def].tri == yes) {
  351. conf_warning("%s creates inconsistent choice state", sym->name);
  352. cs->flags &= ~def_flags;
  353. }
  354. break;
  355. case yes:
  356. if (cs->def[def].tri != no)
  357. conf_warning("override: %s changes choice state", sym->name);
  358. cs->def[def].val = sym;
  359. break;
  360. }
  361. cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri);
  362. }
  363. }
  364. free(line);
  365. fclose(in);
  366. return 0;
  367. }
  368. int conf_read(const char *name)
  369. {
  370. struct symbol *sym;
  371. int conf_unsaved = 0;
  372. int i;
  373. sym_set_change_count(0);
  374. if (conf_read_simple(name, S_DEF_USER)) {
  375. sym_calc_value(modules_sym);
  376. return 1;
  377. }
  378. sym_calc_value(modules_sym);
  379. for_all_symbols(i, sym) {
  380. sym_calc_value(sym);
  381. if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
  382. continue;
  383. if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
  384. /* check that calculated value agrees with saved value */
  385. switch (sym->type) {
  386. case S_BOOLEAN:
  387. case S_TRISTATE:
  388. if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
  389. break;
  390. if (!sym_is_choice(sym))
  391. continue;
  392. /* fall through */
  393. default:
  394. if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
  395. continue;
  396. break;
  397. }
  398. } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
  399. /* no previous value and not saved */
  400. continue;
  401. conf_unsaved++;
  402. /* maybe print value in verbose mode... */
  403. }
  404. for_all_symbols(i, sym) {
  405. if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
  406. /* Reset values of generates values, so they'll appear
  407. * as new, if they should become visible, but that
  408. * doesn't quite work if the Kconfig and the saved
  409. * configuration disagree.
  410. */
  411. if (sym->visible == no && !conf_unsaved)
  412. sym->flags &= ~SYMBOL_DEF_USER;
  413. switch (sym->type) {
  414. case S_STRING:
  415. case S_INT:
  416. case S_HEX:
  417. /* Reset a string value if it's out of range */
  418. if (sym_string_within_range(sym, sym->def[S_DEF_USER].val))
  419. break;
  420. sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
  421. conf_unsaved++;
  422. break;
  423. default:
  424. break;
  425. }
  426. }
  427. }
  428. sym_add_change_count(conf_warnings || conf_unsaved);
  429. return 0;
  430. }
  431. /*
  432. * Kconfig configuration printer
  433. *
  434. * This printer is used when generating the resulting configuration after
  435. * kconfig invocation and `defconfig' files. Unset symbol might be omitted by
  436. * passing a non-NULL argument to the printer.
  437. *
  438. */
  439. static void
  440. kconfig_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg)
  441. {
  442. switch (sym->type) {
  443. case S_BOOLEAN:
  444. case S_TRISTATE:
  445. if (*value == 'n') {
  446. bool skip_unset = (arg != NULL);
  447. if (!skip_unset)
  448. fprintf(fp, "# %s%s is not set\n",
  449. CONFIG_, sym->name);
  450. return;
  451. }
  452. break;
  453. default:
  454. break;
  455. }
  456. fprintf(fp, "%s%s=%s\n", CONFIG_, sym->name, value);
  457. }
  458. static void
  459. kconfig_print_comment(FILE *fp, const char *value, void *arg)
  460. {
  461. const char *p = value;
  462. size_t l;
  463. for (;;) {
  464. l = strcspn(p, "\n");
  465. fprintf(fp, "#");
  466. if (l) {
  467. fprintf(fp, " ");
  468. xfwrite(p, l, 1, fp);
  469. p += l;
  470. }
  471. fprintf(fp, "\n");
  472. if (*p++ == '\0')
  473. break;
  474. }
  475. }
  476. static struct conf_printer kconfig_printer_cb =
  477. {
  478. .print_symbol = kconfig_print_symbol,
  479. .print_comment = kconfig_print_comment,
  480. };
  481. /*
  482. * Header printer
  483. *
  484. * This printer is used when generating the `include/generated/autoconf.h' file.
  485. */
  486. static void
  487. header_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg)
  488. {
  489. switch (sym->type) {
  490. case S_BOOLEAN:
  491. case S_TRISTATE: {
  492. const char *suffix = "";
  493. switch (*value) {
  494. case 'n':
  495. break;
  496. case 'm':
  497. suffix = "_MODULE";
  498. /* fall through */
  499. default:
  500. fprintf(fp, "#define %s%s%s 1\n",
  501. CONFIG_, sym->name, suffix);
  502. }
  503. break;
  504. }
  505. case S_HEX: {
  506. const char *prefix = "";
  507. if (value[0] != '0' || (value[1] != 'x' && value[1] != 'X'))
  508. prefix = "0x";
  509. fprintf(fp, "#define %s%s %s%s\n",
  510. CONFIG_, sym->name, prefix, value);
  511. break;
  512. }
  513. case S_STRING:
  514. case S_INT:
  515. fprintf(fp, "#define %s%s %s\n",
  516. CONFIG_, sym->name, value);
  517. break;
  518. default:
  519. break;
  520. }
  521. }
  522. static void
  523. header_print_comment(FILE *fp, const char *value, void *arg)
  524. {
  525. const char *p = value;
  526. size_t l;
  527. fprintf(fp, "/*\n");
  528. for (;;) {
  529. l = strcspn(p, "\n");
  530. fprintf(fp, " *");
  531. if (l) {
  532. fprintf(fp, " ");
  533. xfwrite(p, l, 1, fp);
  534. p += l;
  535. }
  536. fprintf(fp, "\n");
  537. if (*p++ == '\0')
  538. break;
  539. }
  540. fprintf(fp, " */\n");
  541. }
  542. static struct conf_printer header_printer_cb =
  543. {
  544. .print_symbol = header_print_symbol,
  545. .print_comment = header_print_comment,
  546. };
  547. /*
  548. * Tristate printer
  549. *
  550. * This printer is used when generating the `include/config/tristate.conf' file.
  551. */
  552. static void
  553. tristate_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg)
  554. {
  555. if (sym->type == S_TRISTATE && *value != 'n')
  556. fprintf(fp, "%s%s=%c\n", CONFIG_, sym->name, (char)toupper(*value));
  557. }
  558. static struct conf_printer tristate_printer_cb =
  559. {
  560. .print_symbol = tristate_print_symbol,
  561. .print_comment = kconfig_print_comment,
  562. };
  563. static void conf_write_symbol(FILE *fp, struct symbol *sym,
  564. struct conf_printer *printer, void *printer_arg)
  565. {
  566. const char *str;
  567. switch (sym->type) {
  568. case S_OTHER:
  569. case S_UNKNOWN:
  570. break;
  571. case S_STRING:
  572. str = sym_get_string_value(sym);
  573. str = sym_escape_string_value(str);
  574. printer->print_symbol(fp, sym, str, printer_arg);
  575. free((void *)str);
  576. break;
  577. default:
  578. str = sym_get_string_value(sym);
  579. printer->print_symbol(fp, sym, str, printer_arg);
  580. }
  581. }
  582. static void
  583. conf_write_heading(FILE *fp, struct conf_printer *printer, void *printer_arg)
  584. {
  585. char buf[256];
  586. snprintf(buf, sizeof(buf),
  587. "\n"
  588. "Automatically generated file; DO NOT EDIT.\n"
  589. "%s\n",
  590. rootmenu.prompt->text);
  591. printer->print_comment(fp, buf, printer_arg);
  592. }
  593. /*
  594. * Write out a minimal config.
  595. * All values that has default values are skipped as this is redundant.
  596. */
  597. int conf_write_defconfig(const char *filename)
  598. {
  599. struct symbol *sym;
  600. struct menu *menu;
  601. FILE *out;
  602. out = fopen(filename, "w");
  603. if (!out)
  604. return 1;
  605. sym_clear_all_valid();
  606. /* Traverse all menus to find all relevant symbols */
  607. menu = rootmenu.list;
  608. while (menu != NULL)
  609. {
  610. sym = menu->sym;
  611. if (sym == NULL) {
  612. if (!menu_is_visible(menu))
  613. goto next_menu;
  614. } else if (!sym_is_choice(sym)) {
  615. sym_calc_value(sym);
  616. if (!(sym->flags & SYMBOL_WRITE))
  617. goto next_menu;
  618. sym->flags &= ~SYMBOL_WRITE;
  619. /* If we cannot change the symbol - skip */
  620. if (!sym_is_changable(sym))
  621. goto next_menu;
  622. /* If symbol equals to default value - skip */
  623. if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)
  624. goto next_menu;
  625. /*
  626. * If symbol is a choice value and equals to the
  627. * default for a choice - skip.
  628. * But only if value is bool and equal to "y" and
  629. * choice is not "optional".
  630. * (If choice is "optional" then all values can be "n")
  631. */
  632. if (sym_is_choice_value(sym)) {
  633. struct symbol *cs;
  634. struct symbol *ds;
  635. cs = prop_get_symbol(sym_get_choice_prop(sym));
  636. ds = sym_choice_default(cs);
  637. if (!sym_is_optional(cs) && sym == ds) {
  638. if ((sym->type == S_BOOLEAN) &&
  639. sym_get_tristate_value(sym) == yes)
  640. goto next_menu;
  641. }
  642. }
  643. conf_write_symbol(out, sym, &kconfig_printer_cb, NULL);
  644. }
  645. next_menu:
  646. if (menu->list != NULL) {
  647. menu = menu->list;
  648. }
  649. else if (menu->next != NULL) {
  650. menu = menu->next;
  651. } else {
  652. while ((menu = menu->parent)) {
  653. if (menu->next != NULL) {
  654. menu = menu->next;
  655. break;
  656. }
  657. }
  658. }
  659. }
  660. fclose(out);
  661. return 0;
  662. }
  663. int conf_write(const char *name)
  664. {
  665. FILE *out;
  666. struct symbol *sym;
  667. struct menu *menu;
  668. const char *basename;
  669. const char *str;
  670. char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1];
  671. char *env;
  672. if (!name)
  673. name = conf_get_configname();
  674. dirname[0] = 0;
  675. if (name && name[0]) {
  676. struct stat st;
  677. char *slash;
  678. if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
  679. strcpy(dirname, name);
  680. strcat(dirname, "/");
  681. basename = conf_get_configname();
  682. } else if ((slash = strrchr(name, '/'))) {
  683. int size = slash - name + 1;
  684. memcpy(dirname, name, size);
  685. dirname[size] = 0;
  686. if (slash[1])
  687. basename = slash + 1;
  688. else
  689. basename = conf_get_configname();
  690. } else
  691. basename = name;
  692. } else
  693. basename = conf_get_configname();
  694. sprintf(newname, "%s%s", dirname, basename);
  695. env = getenv("KCONFIG_OVERWRITECONFIG");
  696. if (!env || !*env) {
  697. sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
  698. out = fopen(tmpname, "w");
  699. } else {
  700. *tmpname = 0;
  701. out = fopen(newname, "w");
  702. }
  703. if (!out)
  704. return 1;
  705. conf_write_heading(out, &kconfig_printer_cb, NULL);
  706. if (!conf_get_changed())
  707. sym_clear_all_valid();
  708. menu = rootmenu.list;
  709. while (menu) {
  710. sym = menu->sym;
  711. if (!sym) {
  712. if (!menu_is_visible(menu))
  713. goto next;
  714. str = menu_get_prompt(menu);
  715. fprintf(out, "\n"
  716. "#\n"
  717. "# %s\n"
  718. "#\n", str);
  719. } else if (!(sym->flags & SYMBOL_CHOICE)) {
  720. sym_calc_value(sym);
  721. if (!(sym->flags & SYMBOL_WRITE))
  722. goto next;
  723. sym->flags &= ~SYMBOL_WRITE;
  724. conf_write_symbol(out, sym, &kconfig_printer_cb, NULL);
  725. }
  726. next:
  727. if (menu->list) {
  728. menu = menu->list;
  729. continue;
  730. }
  731. if (menu->next)
  732. menu = menu->next;
  733. else while ((menu = menu->parent)) {
  734. if (menu->next) {
  735. menu = menu->next;
  736. break;
  737. }
  738. }
  739. }
  740. fclose(out);
  741. if (*tmpname) {
  742. strcat(dirname, basename);
  743. strcat(dirname, ".old");
  744. rename(newname, dirname);
  745. if (rename(tmpname, newname))
  746. return 1;
  747. }
  748. conf_message(_("configuration written to %s"), newname);
  749. sym_set_change_count(0);
  750. return 0;
  751. }
  752. static int conf_split_config(void)
  753. {
  754. const char *name;
  755. char path[PATH_MAX+1];
  756. char *opwd, *dir, *_name;
  757. char *s, *d, c;
  758. struct symbol *sym;
  759. struct stat sb;
  760. int res, i, fd;
  761. name = conf_get_autoconfig_name();
  762. conf_read_simple(name, S_DEF_AUTO);
  763. sym_calc_value(modules_sym);
  764. opwd = malloc(256);
  765. _name = strdup(name);
  766. if (opwd == NULL || _name == NULL)
  767. return 1;
  768. opwd = getcwd(opwd, 256);
  769. dir = dirname(_name);
  770. if (dir == NULL) {
  771. res = 1;
  772. goto err;
  773. }
  774. if (chdir(dir)) {
  775. res = 1;
  776. goto err;
  777. }
  778. res = 0;
  779. for_all_symbols(i, sym) {
  780. sym_calc_value(sym);
  781. if ((sym->flags & SYMBOL_AUTO) || !sym->name)
  782. continue;
  783. if (sym->flags & SYMBOL_WRITE) {
  784. if (sym->flags & SYMBOL_DEF_AUTO) {
  785. /*
  786. * symbol has old and new value,
  787. * so compare them...
  788. */
  789. switch (sym->type) {
  790. case S_BOOLEAN:
  791. case S_TRISTATE:
  792. if (sym_get_tristate_value(sym) ==
  793. sym->def[S_DEF_AUTO].tri)
  794. continue;
  795. break;
  796. case S_STRING:
  797. case S_HEX:
  798. case S_INT:
  799. if (!strcmp(sym_get_string_value(sym),
  800. sym->def[S_DEF_AUTO].val))
  801. continue;
  802. break;
  803. default:
  804. break;
  805. }
  806. } else {
  807. /*
  808. * If there is no old value, only 'no' (unset)
  809. * is allowed as new value.
  810. */
  811. switch (sym->type) {
  812. case S_BOOLEAN:
  813. case S_TRISTATE:
  814. if (sym_get_tristate_value(sym) == no)
  815. continue;
  816. break;
  817. default:
  818. break;
  819. }
  820. }
  821. } else if (!(sym->flags & SYMBOL_DEF_AUTO))
  822. /* There is neither an old nor a new value. */
  823. continue;
  824. /* else
  825. * There is an old value, but no new value ('no' (unset)
  826. * isn't saved in auto.conf, so the old value is always
  827. * different from 'no').
  828. */
  829. /* Replace all '_' and append ".h" */
  830. s = sym->name;
  831. d = path;
  832. while ((c = *s++)) {
  833. c = tolower(c);
  834. *d++ = (c == '_') ? '/' : c;
  835. }
  836. strcpy(d, ".h");
  837. /* Assume directory path already exists. */
  838. fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  839. if (fd == -1) {
  840. if (errno != ENOENT) {
  841. res = 1;
  842. break;
  843. }
  844. /*
  845. * Create directory components,
  846. * unless they exist already.
  847. */
  848. d = path;
  849. while ((d = strchr(d, '/'))) {
  850. *d = 0;
  851. if (stat(path, &sb) && mkdir(path, 0755)) {
  852. res = 1;
  853. goto out;
  854. }
  855. *d++ = '/';
  856. }
  857. /* Try it again. */
  858. fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  859. if (fd == -1) {
  860. res = 1;
  861. break;
  862. }
  863. }
  864. close(fd);
  865. }
  866. out:
  867. if (chdir(opwd))
  868. res = 1;
  869. err:
  870. free(opwd);
  871. free(_name);
  872. return res;
  873. }
  874. int conf_write_autoconf(void)
  875. {
  876. struct symbol *sym;
  877. const char *name;
  878. FILE *out, *tristate, *out_h;
  879. int i;
  880. char dir[PATH_MAX+1], buf[PATH_MAX+1];
  881. char *s;
  882. strcpy(dir, conf_get_configname());
  883. s = strrchr(dir, '/');
  884. if (s)
  885. s[1] = 0;
  886. else
  887. dir[0] = 0;
  888. sym_clear_all_valid();
  889. sprintf(buf, "%s.config.cmd", dir);
  890. file_write_dep(buf);
  891. if (conf_split_config())
  892. return 1;
  893. sprintf(buf, "%s.tmpconfig", dir);
  894. out = fopen(buf, "w");
  895. if (!out)
  896. return 1;
  897. sprintf(buf, "%s.tmpconfig_tristate", dir);
  898. tristate = fopen(buf, "w");
  899. if (!tristate) {
  900. fclose(out);
  901. return 1;
  902. }
  903. sprintf(buf, "%s.tmpconfig.h", dir);
  904. out_h = fopen(buf, "w");
  905. if (!out_h) {
  906. fclose(out);
  907. fclose(tristate);
  908. return 1;
  909. }
  910. conf_write_heading(out, &kconfig_printer_cb, NULL);
  911. conf_write_heading(tristate, &tristate_printer_cb, NULL);
  912. conf_write_heading(out_h, &header_printer_cb, NULL);
  913. for_all_symbols(i, sym) {
  914. sym_calc_value(sym);
  915. if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
  916. continue;
  917. /* write symbol to auto.conf, tristate and header files */
  918. conf_write_symbol(out, sym, &kconfig_printer_cb, (void *)1);
  919. conf_write_symbol(tristate, sym, &tristate_printer_cb, (void *)1);
  920. conf_write_symbol(out_h, sym, &header_printer_cb, NULL);
  921. }
  922. fclose(out);
  923. fclose(tristate);
  924. fclose(out_h);
  925. name = getenv("KCONFIG_AUTOHEADER");
  926. if (!name)
  927. name = "include/generated/autoconf.h";
  928. sprintf(buf, "%s.tmpconfig.h", dir);
  929. if (rename(buf, name))
  930. return 1;
  931. name = getenv("KCONFIG_TRISTATE");
  932. if (!name)
  933. name = "include/config/tristate.conf";
  934. sprintf(buf, "%s.tmpconfig_tristate", dir);
  935. if (rename(buf, name))
  936. return 1;
  937. name = conf_get_autoconfig_name();
  938. /*
  939. * This must be the last step, kbuild has a dependency on auto.conf
  940. * and this marks the successful completion of the previous steps.
  941. */
  942. sprintf(buf, "%s.tmpconfig", dir);
  943. if (rename(buf, name))
  944. return 1;
  945. return 0;
  946. }
  947. static int sym_change_count;
  948. static void (*conf_changed_callback)(void);
  949. void sym_set_change_count(int count)
  950. {
  951. int _sym_change_count = sym_change_count;
  952. sym_change_count = count;
  953. if (conf_changed_callback &&
  954. (bool)_sym_change_count != (bool)count)
  955. conf_changed_callback();
  956. }
  957. void sym_add_change_count(int count)
  958. {
  959. sym_set_change_count(count + sym_change_count);
  960. }
  961. bool conf_get_changed(void)
  962. {
  963. return sym_change_count;
  964. }
  965. void conf_set_changed_callback(void (*fn)(void))
  966. {
  967. conf_changed_callback = fn;
  968. }
  969. static bool randomize_choice_values(struct symbol *csym)
  970. {
  971. struct property *prop;
  972. struct symbol *sym;
  973. struct expr *e;
  974. int cnt, def;
  975. /*
  976. * If choice is mod then we may have more items selected
  977. * and if no then no-one.
  978. * In both cases stop.
  979. */
  980. if (csym->curr.tri != yes)
  981. return false;
  982. prop = sym_get_choice_prop(csym);
  983. /* count entries in choice block */
  984. cnt = 0;
  985. expr_list_for_each_sym(prop->expr, e, sym)
  986. cnt++;
  987. /*
  988. * find a random value and set it to yes,
  989. * set the rest to no so we have only one set
  990. */
  991. def = (rand() % cnt);
  992. cnt = 0;
  993. expr_list_for_each_sym(prop->expr, e, sym) {
  994. if (def == cnt++) {
  995. sym->def[S_DEF_USER].tri = yes;
  996. csym->def[S_DEF_USER].val = sym;
  997. }
  998. else {
  999. sym->def[S_DEF_USER].tri = no;
  1000. }
  1001. sym->flags |= SYMBOL_DEF_USER;
  1002. /* clear VALID to get value calculated */
  1003. sym->flags &= ~SYMBOL_VALID;
  1004. }
  1005. csym->flags |= SYMBOL_DEF_USER;
  1006. /* clear VALID to get value calculated */
  1007. csym->flags &= ~(SYMBOL_VALID);
  1008. return true;
  1009. }
  1010. void set_all_choice_values(struct symbol *csym)
  1011. {
  1012. struct property *prop;
  1013. struct symbol *sym;
  1014. struct expr *e;
  1015. prop = sym_get_choice_prop(csym);
  1016. /*
  1017. * Set all non-assinged choice values to no
  1018. */
  1019. expr_list_for_each_sym(prop->expr, e, sym) {
  1020. if (!sym_has_value(sym))
  1021. sym->def[S_DEF_USER].tri = no;
  1022. }
  1023. csym->flags |= SYMBOL_DEF_USER;
  1024. /* clear VALID to get value calculated */
  1025. csym->flags &= ~(SYMBOL_VALID | SYMBOL_NEED_SET_CHOICE_VALUES);
  1026. }
  1027. bool conf_set_all_new_symbols(enum conf_def_mode mode)
  1028. {
  1029. struct symbol *sym, *csym;
  1030. int i, cnt, pby, pty, ptm; /* pby: probability of bool = y
  1031. * pty: probability of tristate = y
  1032. * ptm: probability of tristate = m
  1033. */
  1034. pby = 50; pty = ptm = 33; /* can't go as the default in switch-case
  1035. * below, otherwise gcc whines about
  1036. * -Wmaybe-uninitialized */
  1037. if (mode == def_random) {
  1038. int n, p[3];
  1039. char *env = getenv("KCONFIG_PROBABILITY");
  1040. n = 0;
  1041. while( env && *env ) {
  1042. char *endp;
  1043. int tmp = strtol( env, &endp, 10 );
  1044. if( tmp >= 0 && tmp <= 100 ) {
  1045. p[n++] = tmp;
  1046. } else {
  1047. errno = ERANGE;
  1048. perror( "KCONFIG_PROBABILITY" );
  1049. exit( 1 );
  1050. }
  1051. env = (*endp == ':') ? endp+1 : endp;
  1052. if( n >=3 ) {
  1053. break;
  1054. }
  1055. }
  1056. switch( n ) {
  1057. case 1:
  1058. pby = p[0]; ptm = pby/2; pty = pby-ptm;
  1059. break;
  1060. case 2:
  1061. pty = p[0]; ptm = p[1]; pby = pty + ptm;
  1062. break;
  1063. case 3:
  1064. pby = p[0]; pty = p[1]; ptm = p[2];
  1065. break;
  1066. }
  1067. if( pty+ptm > 100 ) {
  1068. errno = ERANGE;
  1069. perror( "KCONFIG_PROBABILITY" );
  1070. exit( 1 );
  1071. }
  1072. }
  1073. bool has_changed = false;
  1074. for_all_symbols(i, sym) {
  1075. if (sym_has_value(sym) || (sym->flags & SYMBOL_VALID))
  1076. continue;
  1077. switch (sym_get_type(sym)) {
  1078. case S_BOOLEAN:
  1079. case S_TRISTATE:
  1080. has_changed = true;
  1081. switch (mode) {
  1082. case def_yes:
  1083. sym->def[S_DEF_USER].tri = yes;
  1084. break;
  1085. case def_mod:
  1086. sym->def[S_DEF_USER].tri = mod;
  1087. break;
  1088. case def_no:
  1089. if (sym->flags & SYMBOL_ALLNOCONFIG_Y)
  1090. sym->def[S_DEF_USER].tri = yes;
  1091. else
  1092. sym->def[S_DEF_USER].tri = no;
  1093. break;
  1094. case def_random:
  1095. sym->def[S_DEF_USER].tri = no;
  1096. cnt = rand() % 100;
  1097. if (sym->type == S_TRISTATE) {
  1098. if (cnt < pty)
  1099. sym->def[S_DEF_USER].tri = yes;
  1100. else if (cnt < (pty+ptm))
  1101. sym->def[S_DEF_USER].tri = mod;
  1102. } else if (cnt < pby)
  1103. sym->def[S_DEF_USER].tri = yes;
  1104. break;
  1105. default:
  1106. continue;
  1107. }
  1108. if (!(sym_is_choice(sym) && mode == def_random))
  1109. sym->flags |= SYMBOL_DEF_USER;
  1110. break;
  1111. default:
  1112. break;
  1113. }
  1114. }
  1115. sym_clear_all_valid();
  1116. /*
  1117. * We have different type of choice blocks.
  1118. * If curr.tri equals to mod then we can select several
  1119. * choice symbols in one block.
  1120. * In this case we do nothing.
  1121. * If curr.tri equals yes then only one symbol can be
  1122. * selected in a choice block and we set it to yes,
  1123. * and the rest to no.
  1124. */
  1125. if (mode != def_random) {
  1126. for_all_symbols(i, csym) {
  1127. if ((sym_is_choice(csym) && !sym_has_value(csym)) ||
  1128. sym_is_choice_value(csym))
  1129. csym->flags |= SYMBOL_NEED_SET_CHOICE_VALUES;
  1130. }
  1131. }
  1132. for_all_symbols(i, csym) {
  1133. if (sym_has_value(csym) || !sym_is_choice(csym))
  1134. continue;
  1135. sym_calc_value(csym);
  1136. if (mode == def_random)
  1137. has_changed = randomize_choice_values(csym);
  1138. else {
  1139. set_all_choice_values(csym);
  1140. has_changed = true;
  1141. }
  1142. }
  1143. return has_changed;
  1144. }