2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
|
|
|
|
* Released under the terms of the GNU GPL v2.0.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <ctype.h>
|
2006-06-09 07:12:42 +02:00
|
|
|
#include <fcntl.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#define LKC_DIRECT_LINK
|
|
|
|
#include "lkc.h"
|
|
|
|
|
2005-11-09 06:34:54 +01:00
|
|
|
static void conf_warning(const char *fmt, ...)
|
|
|
|
__attribute__ ((format (printf, 1, 2)));
|
|
|
|
|
|
|
|
static const char *conf_filename;
|
|
|
|
static int conf_lineno, conf_warnings, conf_unsaved;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
const char conf_defname[] = "arch/$ARCH/defconfig";
|
|
|
|
|
2005-11-09 06:34:54 +01:00
|
|
|
static void conf_warning(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
va_end(ap);
|
|
|
|
conf_warnings++;
|
|
|
|
}
|
|
|
|
|
2006-06-09 07:12:51 +02:00
|
|
|
const char *conf_get_configname(void)
|
|
|
|
{
|
|
|
|
char *name = getenv("KCONFIG_CONFIG");
|
|
|
|
|
|
|
|
return name ? name : ".config";
|
|
|
|
}
|
|
|
|
|
2005-06-25 23:59:22 +02:00
|
|
|
static char *conf_expand_value(const char *in)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct symbol *sym;
|
2005-06-25 23:59:22 +02:00
|
|
|
const char *src;
|
2005-04-17 00:20:36 +02:00
|
|
|
static char res_value[SYMBOL_MAXLENGTH];
|
|
|
|
char *dst, name[SYMBOL_MAXLENGTH];
|
|
|
|
|
|
|
|
res_value[0] = 0;
|
|
|
|
dst = name;
|
|
|
|
while ((src = strchr(in, '$'))) {
|
|
|
|
strncat(res_value, in, src - in);
|
|
|
|
src++;
|
|
|
|
dst = name;
|
|
|
|
while (isalnum(*src) || *src == '_')
|
|
|
|
*dst++ = *src++;
|
|
|
|
*dst = 0;
|
|
|
|
sym = sym_lookup(name, 0);
|
|
|
|
sym_calc_value(sym);
|
|
|
|
strcat(res_value, sym_get_string_value(sym));
|
|
|
|
in = src;
|
|
|
|
}
|
|
|
|
strcat(res_value, in);
|
|
|
|
|
|
|
|
return res_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
char *conf_get_default_confname(void)
|
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
static char fullname[PATH_MAX+1];
|
|
|
|
char *env, *name;
|
|
|
|
|
|
|
|
name = conf_expand_value(conf_defname);
|
|
|
|
env = getenv(SRCTREE);
|
|
|
|
if (env) {
|
|
|
|
sprintf(fullname, "%s/%s", env, name);
|
|
|
|
if (!stat(fullname, &buf))
|
|
|
|
return fullname;
|
|
|
|
}
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
2006-06-09 07:12:42 +02:00
|
|
|
int conf_read_simple(const char *name, int def)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
FILE *in = NULL;
|
|
|
|
char line[1024];
|
|
|
|
char *p, *p2;
|
|
|
|
struct symbol *sym;
|
2006-06-09 07:12:42 +02:00
|
|
|
int i, def_flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (name) {
|
|
|
|
in = zconf_fopen(name);
|
|
|
|
} else {
|
2006-06-09 07:12:45 +02:00
|
|
|
struct property *prop;
|
|
|
|
|
2006-06-09 07:12:51 +02:00
|
|
|
name = conf_get_configname();
|
2006-06-09 07:12:38 +02:00
|
|
|
in = zconf_fopen(name);
|
|
|
|
if (in)
|
|
|
|
goto load;
|
|
|
|
sym_change_count++;
|
2006-06-09 07:12:45 +02:00
|
|
|
if (!sym_defconfig_list)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for_all_defaults(sym_defconfig_list, prop) {
|
|
|
|
if (expr_calc_value(prop->visible.expr) == no ||
|
|
|
|
prop->expr->type != E_SYMBOL)
|
|
|
|
continue;
|
|
|
|
name = conf_expand_value(prop->expr->left.sym->name);
|
2005-04-17 00:20:36 +02:00
|
|
|
in = zconf_fopen(name);
|
|
|
|
if (in) {
|
[PATCH] Kconfig i18n support
This patch adds i18n support for make *config, allowing users to have the
config process in their own language.
No printk was harmed in the process, don't worry, so all the bug reports,
kernel messages, etc, remain in english, just the user tools to configure
the kernel are internationalized.
Users not interested in translations can just unset the related LANG,
LC_ALL, etc env variables and have the config process in plain english,
something like:
LANG= make menuconfig
is enough for having the whole config process in english. Or just don't
install any translation file.
Translations for brazilian portuguese are being done by a team of
volunteers at:
http://www.visionflex.inf.br/kernel_ptbr/pmwiki.php/Principal/Traducoes
To start the translation process:
make update-po-config
This will generate the pot template named scripts/kconfig/linux.pot,
copy it to, say, ~/es.po, to start the translation for spanish.
To test your translation, as root issue this command:
msgfmt -o /usr/share/locale/es/LC_MESSAGES/linux.mo ~/es.po
Replace "es" with your language code.
Then execute, for instance:
make menuconfig
The current patch doesn't use any optimization to reduce the size of the
generated .mo file, it is possible to use the config option as a key, but
this doesn't prevent the current patch from being used or the translations
done under the current scheme to be in any way lost if we chose to do any
kind of keying.
Thanks to Fabricio Vaccari for starting the pt_BR (brazilian portuguese)
translation effort, Thiago Maciera for helping me with the gconf.cc (QT
frontent) i18n coding and to all the volunteers that are already working on
the first translation, to pt_BR.
I left the question on whether to ship the translations with the stock kernel
sources to be discussed here, please share your suggestions.
Signed-off-by: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org
Signed-off-by: Andrew Morton <akpm@osdl.org>
2005-05-06 00:09:46 +02:00
|
|
|
printf(_("#\n"
|
2006-06-09 07:12:38 +02:00
|
|
|
"# using defaults found in %s\n"
|
|
|
|
"#\n"), name);
|
|
|
|
goto load;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!in)
|
|
|
|
return 1;
|
|
|
|
|
2006-06-09 07:12:38 +02:00
|
|
|
load:
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_filename = name;
|
|
|
|
conf_lineno = 0;
|
|
|
|
conf_warnings = 0;
|
|
|
|
conf_unsaved = 0;
|
|
|
|
|
2006-06-09 07:12:42 +02:00
|
|
|
def_flags = SYMBOL_DEF << def;
|
2005-04-17 00:20:36 +02:00
|
|
|
for_all_symbols(i, sym) {
|
2006-06-09 07:12:42 +02:00
|
|
|
sym->flags |= SYMBOL_CHANGED;
|
|
|
|
sym->flags &= ~(def_flags|SYMBOL_VALID);
|
2005-11-09 06:34:54 +01:00
|
|
|
if (sym_is_choice(sym))
|
2006-06-09 07:12:42 +02:00
|
|
|
sym->flags |= def_flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (sym->type) {
|
|
|
|
case S_INT:
|
|
|
|
case S_HEX:
|
|
|
|
case S_STRING:
|
2006-06-09 07:12:42 +02:00
|
|
|
if (sym->def[def].val)
|
|
|
|
free(sym->def[def].val);
|
2005-04-17 00:20:36 +02:00
|
|
|
default:
|
2006-06-09 07:12:42 +02:00
|
|
|
sym->def[def].val = NULL;
|
|
|
|
sym->def[def].tri = no;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (fgets(line, sizeof(line), in)) {
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_lineno++;
|
2005-04-17 00:20:36 +02:00
|
|
|
sym = NULL;
|
|
|
|
switch (line[0]) {
|
|
|
|
case '#':
|
|
|
|
if (memcmp(line + 2, "CONFIG_", 7))
|
|
|
|
continue;
|
|
|
|
p = strchr(line + 9, ' ');
|
|
|
|
if (!p)
|
|
|
|
continue;
|
|
|
|
*p++ = 0;
|
|
|
|
if (strncmp(p, "is not set", 10))
|
|
|
|
continue;
|
2006-06-09 07:12:42 +02:00
|
|
|
if (def == S_DEF_USER) {
|
|
|
|
sym = sym_find(line + 9);
|
|
|
|
if (!sym) {
|
|
|
|
conf_warning("trying to assign nonexistent symbol %s", line + 9);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
sym = sym_lookup(line + 9, 0);
|
|
|
|
if (sym->type == S_UNKNOWN)
|
|
|
|
sym->type = S_BOOLEAN;
|
|
|
|
}
|
|
|
|
if (sym->flags & def_flags) {
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_warning("trying to reassign symbol %s", sym->name);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch (sym->type) {
|
|
|
|
case S_BOOLEAN:
|
|
|
|
case S_TRISTATE:
|
2006-06-09 07:12:42 +02:00
|
|
|
sym->def[def].tri = no;
|
|
|
|
sym->flags |= def_flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'C':
|
2005-11-09 06:34:54 +01:00
|
|
|
if (memcmp(line, "CONFIG_", 7)) {
|
|
|
|
conf_warning("unexpected data");
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
2005-11-09 06:34:54 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
p = strchr(line + 7, '=');
|
|
|
|
if (!p)
|
|
|
|
continue;
|
|
|
|
*p++ = 0;
|
|
|
|
p2 = strchr(p, '\n');
|
2006-07-13 20:54:07 +02:00
|
|
|
if (p2) {
|
|
|
|
*p2-- = 0;
|
|
|
|
if (*p2 == '\r')
|
|
|
|
*p2 = 0;
|
|
|
|
}
|
2006-06-09 07:12:42 +02:00
|
|
|
if (def == S_DEF_USER) {
|
|
|
|
sym = sym_find(line + 7);
|
|
|
|
if (!sym) {
|
|
|
|
conf_warning("trying to assign nonexistent symbol %s", line + 7);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
sym = sym_lookup(line + 7, 0);
|
|
|
|
if (sym->type == S_UNKNOWN)
|
|
|
|
sym->type = S_OTHER;
|
|
|
|
}
|
|
|
|
if (sym->flags & def_flags) {
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_warning("trying to reassign symbol %s", sym->name);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch (sym->type) {
|
|
|
|
case S_TRISTATE:
|
|
|
|
if (p[0] == 'm') {
|
2006-06-09 07:12:42 +02:00
|
|
|
sym->def[def].tri = mod;
|
|
|
|
sym->flags |= def_flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case S_BOOLEAN:
|
|
|
|
if (p[0] == 'y') {
|
2006-06-09 07:12:42 +02:00
|
|
|
sym->def[def].tri = yes;
|
|
|
|
sym->flags |= def_flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (p[0] == 'n') {
|
2006-06-09 07:12:42 +02:00
|
|
|
sym->def[def].tri = no;
|
|
|
|
sym->flags |= def_flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_warning("symbol value '%s' invalid for %s", p, sym->name);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
2006-06-09 07:12:42 +02:00
|
|
|
case S_OTHER:
|
|
|
|
if (*p != '"') {
|
|
|
|
for (p2 = p; *p2 && !isspace(*p2); p2++)
|
|
|
|
;
|
|
|
|
sym->type = S_STRING;
|
|
|
|
goto done;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
case S_STRING:
|
|
|
|
if (*p++ != '"')
|
|
|
|
break;
|
|
|
|
for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
|
|
|
|
if (*p2 == '"') {
|
|
|
|
*p2 = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
memmove(p2, p2 + 1, strlen(p2));
|
|
|
|
}
|
|
|
|
if (!p2) {
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_warning("invalid string found");
|
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
case S_INT:
|
|
|
|
case S_HEX:
|
2006-06-09 07:12:42 +02:00
|
|
|
done:
|
2005-04-17 00:20:36 +02:00
|
|
|
if (sym_string_valid(sym, p)) {
|
2006-06-09 07:12:42 +02:00
|
|
|
sym->def[def].val = strdup(p);
|
|
|
|
sym->flags |= def_flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_warning("symbol value '%s' invalid for %s", p, sym->name);
|
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
break;
|
2006-07-13 20:54:07 +02:00
|
|
|
case '\r':
|
2005-04-17 00:20:36 +02:00
|
|
|
case '\n':
|
|
|
|
break;
|
|
|
|
default:
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_warning("unexpected data");
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (sym && sym_is_choice_value(sym)) {
|
|
|
|
struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
|
2006-06-09 07:12:42 +02:00
|
|
|
switch (sym->def[def].tri) {
|
2005-04-17 00:20:36 +02:00
|
|
|
case no:
|
|
|
|
break;
|
|
|
|
case mod:
|
2006-06-09 07:12:42 +02:00
|
|
|
if (cs->def[def].tri == yes) {
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_warning("%s creates inconsistent choice state", sym->name);
|
2006-06-09 07:12:42 +02:00
|
|
|
cs->flags &= ~def_flags;
|
2005-11-09 06:34:54 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case yes:
|
2006-06-09 07:12:42 +02:00
|
|
|
if (cs->def[def].tri != no) {
|
2005-11-09 06:34:54 +01:00
|
|
|
conf_warning("%s creates inconsistent choice state", sym->name);
|
2006-06-09 07:12:42 +02:00
|
|
|
cs->flags &= ~def_flags;
|
2005-11-09 06:34:54 +01:00
|
|
|
} else
|
2006-06-09 07:12:42 +02:00
|
|
|
cs->def[def].val = sym;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
2006-06-09 07:12:42 +02:00
|
|
|
cs->def[def].tri = E_OR(cs->def[def].tri, sym->def[def].tri);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(in);
|
|
|
|
|
|
|
|
if (modules_sym)
|
|
|
|
sym_calc_value(modules_sym);
|
2005-11-09 06:34:49 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int conf_read(const char *name)
|
|
|
|
{
|
|
|
|
struct symbol *sym;
|
|
|
|
struct property *prop;
|
|
|
|
struct expr *e;
|
2006-06-09 07:12:42 +02:00
|
|
|
int i, flags;
|
2005-11-09 06:34:49 +01:00
|
|
|
|
2006-06-09 07:12:38 +02:00
|
|
|
sym_change_count = 0;
|
|
|
|
|
2006-06-09 07:12:42 +02:00
|
|
|
if (conf_read_simple(name, S_DEF_USER))
|
2005-11-09 06:34:49 +01:00
|
|
|
return 1;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
for_all_symbols(i, sym) {
|
|
|
|
sym_calc_value(sym);
|
2005-11-09 06:34:54 +01:00
|
|
|
if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
|
|
|
|
goto sym_ok;
|
|
|
|
if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
|
|
|
|
/* check that calculated value agrees with saved value */
|
|
|
|
switch (sym->type) {
|
|
|
|
case S_BOOLEAN:
|
|
|
|
case S_TRISTATE:
|
2006-06-09 07:12:41 +02:00
|
|
|
if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
|
2005-11-09 06:34:54 +01:00
|
|
|
break;
|
|
|
|
if (!sym_is_choice(sym))
|
|
|
|
goto sym_ok;
|
|
|
|
default:
|
2006-06-09 07:12:41 +02:00
|
|
|
if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
|
2005-11-09 06:34:54 +01:00
|
|
|
goto sym_ok;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
|
|
|
|
/* no previous value and not saved */
|
|
|
|
goto sym_ok;
|
|
|
|
conf_unsaved++;
|
|
|
|
/* maybe print value in verbose mode... */
|
|
|
|
sym_ok:
|
2005-04-17 00:20:36 +02:00
|
|
|
if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
|
|
|
|
if (sym->visible == no)
|
2006-06-09 07:12:42 +02:00
|
|
|
sym->flags &= ~SYMBOL_DEF_USER;
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (sym->type) {
|
|
|
|
case S_STRING:
|
|
|
|
case S_INT:
|
|
|
|
case S_HEX:
|
2006-06-09 07:12:42 +02:00
|
|
|
if (!sym_string_within_range(sym, sym->def[S_DEF_USER].val))
|
|
|
|
sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
|
2005-04-17 00:20:36 +02:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!sym_is_choice(sym))
|
|
|
|
continue;
|
|
|
|
prop = sym_get_choice_prop(sym);
|
2006-06-09 07:12:42 +02:00
|
|
|
flags = sym->flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
for (e = prop->expr; e; e = e->left.expr)
|
|
|
|
if (e->right.sym->visible != no)
|
2006-06-09 07:12:42 +02:00
|
|
|
flags &= e->right.sym->flags;
|
2006-07-13 13:22:38 +02:00
|
|
|
sym->flags &= flags | ~SYMBOL_DEF_USER;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-06-09 07:12:38 +02:00
|
|
|
sym_change_count += conf_warnings || conf_unsaved;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int conf_write(const char *name)
|
|
|
|
{
|
2006-06-09 07:12:39 +02:00
|
|
|
FILE *out;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct symbol *sym;
|
|
|
|
struct menu *menu;
|
|
|
|
const char *basename;
|
|
|
|
char dirname[128], tmpname[128], newname[128];
|
|
|
|
int type, l;
|
|
|
|
const char *str;
|
|
|
|
time_t now;
|
|
|
|
int use_timestamp = 1;
|
|
|
|
char *env;
|
|
|
|
|
|
|
|
dirname[0] = 0;
|
|
|
|
if (name && name[0]) {
|
|
|
|
struct stat st;
|
|
|
|
char *slash;
|
|
|
|
|
|
|
|
if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
|
|
|
|
strcpy(dirname, name);
|
|
|
|
strcat(dirname, "/");
|
2006-06-09 07:12:51 +02:00
|
|
|
basename = conf_get_configname();
|
2005-04-17 00:20:36 +02:00
|
|
|
} else if ((slash = strrchr(name, '/'))) {
|
|
|
|
int size = slash - name + 1;
|
|
|
|
memcpy(dirname, name, size);
|
|
|
|
dirname[size] = 0;
|
|
|
|
if (slash[1])
|
|
|
|
basename = slash + 1;
|
|
|
|
else
|
2006-06-09 07:12:51 +02:00
|
|
|
basename = conf_get_configname();
|
2005-04-17 00:20:36 +02:00
|
|
|
} else
|
|
|
|
basename = name;
|
|
|
|
} else
|
2006-06-09 07:12:51 +02:00
|
|
|
basename = conf_get_configname();
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-06-09 07:12:51 +02:00
|
|
|
sprintf(newname, "%s%s", dirname, basename);
|
|
|
|
env = getenv("KCONFIG_OVERWRITECONFIG");
|
|
|
|
if (!env || !*env) {
|
|
|
|
sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
|
|
|
|
out = fopen(tmpname, "w");
|
|
|
|
} else {
|
|
|
|
*tmpname = 0;
|
|
|
|
out = fopen(newname, "w");
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!out)
|
|
|
|
return 1;
|
2006-06-09 07:12:51 +02:00
|
|
|
|
2006-01-16 12:12:12 +01:00
|
|
|
sym = sym_lookup("KERNELVERSION", 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
sym_calc_value(sym);
|
|
|
|
time(&now);
|
|
|
|
env = getenv("KCONFIG_NOTIMESTAMP");
|
|
|
|
if (env && *env)
|
|
|
|
use_timestamp = 0;
|
|
|
|
|
[PATCH] Kconfig i18n support
This patch adds i18n support for make *config, allowing users to have the
config process in their own language.
No printk was harmed in the process, don't worry, so all the bug reports,
kernel messages, etc, remain in english, just the user tools to configure
the kernel are internationalized.
Users not interested in translations can just unset the related LANG,
LC_ALL, etc env variables and have the config process in plain english,
something like:
LANG= make menuconfig
is enough for having the whole config process in english. Or just don't
install any translation file.
Translations for brazilian portuguese are being done by a team of
volunteers at:
http://www.visionflex.inf.br/kernel_ptbr/pmwiki.php/Principal/Traducoes
To start the translation process:
make update-po-config
This will generate the pot template named scripts/kconfig/linux.pot,
copy it to, say, ~/es.po, to start the translation for spanish.
To test your translation, as root issue this command:
msgfmt -o /usr/share/locale/es/LC_MESSAGES/linux.mo ~/es.po
Replace "es" with your language code.
Then execute, for instance:
make menuconfig
The current patch doesn't use any optimization to reduce the size of the
generated .mo file, it is possible to use the config option as a key, but
this doesn't prevent the current patch from being used or the translations
done under the current scheme to be in any way lost if we chose to do any
kind of keying.
Thanks to Fabricio Vaccari for starting the pt_BR (brazilian portuguese)
translation effort, Thiago Maciera for helping me with the gconf.cc (QT
frontent) i18n coding and to all the volunteers that are already working on
the first translation, to pt_BR.
I left the question on whether to ship the translations with the stock kernel
sources to be discussed here, please share your suggestions.
Signed-off-by: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org
Signed-off-by: Andrew Morton <akpm@osdl.org>
2005-05-06 00:09:46 +02:00
|
|
|
fprintf(out, _("#\n"
|
|
|
|
"# Automatically generated make config: don't edit\n"
|
|
|
|
"# Linux kernel version: %s\n"
|
|
|
|
"%s%s"
|
|
|
|
"#\n"),
|
2005-04-17 00:20:36 +02:00
|
|
|
sym_get_string_value(sym),
|
|
|
|
use_timestamp ? "# " : "",
|
|
|
|
use_timestamp ? ctime(&now) : "");
|
|
|
|
|
|
|
|
if (!sym_change_count)
|
|
|
|
sym_clear_all_valid();
|
|
|
|
|
|
|
|
menu = rootmenu.list;
|
|
|
|
while (menu) {
|
|
|
|
sym = menu->sym;
|
|
|
|
if (!sym) {
|
|
|
|
if (!menu_is_visible(menu))
|
|
|
|
goto next;
|
|
|
|
str = menu_get_prompt(menu);
|
|
|
|
fprintf(out, "\n"
|
|
|
|
"#\n"
|
|
|
|
"# %s\n"
|
|
|
|
"#\n", str);
|
|
|
|
} else if (!(sym->flags & SYMBOL_CHOICE)) {
|
|
|
|
sym_calc_value(sym);
|
|
|
|
if (!(sym->flags & SYMBOL_WRITE))
|
|
|
|
goto next;
|
|
|
|
sym->flags &= ~SYMBOL_WRITE;
|
|
|
|
type = sym->type;
|
|
|
|
if (type == S_TRISTATE) {
|
|
|
|
sym_calc_value(modules_sym);
|
|
|
|
if (modules_sym->curr.tri == no)
|
|
|
|
type = S_BOOLEAN;
|
|
|
|
}
|
|
|
|
switch (type) {
|
|
|
|
case S_BOOLEAN:
|
|
|
|
case S_TRISTATE:
|
|
|
|
switch (sym_get_tristate_value(sym)) {
|
|
|
|
case no:
|
|
|
|
fprintf(out, "# CONFIG_%s is not set\n", sym->name);
|
|
|
|
break;
|
|
|
|
case mod:
|
|
|
|
fprintf(out, "CONFIG_%s=m\n", sym->name);
|
|
|
|
break;
|
|
|
|
case yes:
|
|
|
|
fprintf(out, "CONFIG_%s=y\n", sym->name);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case S_STRING:
|
|
|
|
str = sym_get_string_value(sym);
|
|
|
|
fprintf(out, "CONFIG_%s=\"", sym->name);
|
2006-06-09 07:12:39 +02:00
|
|
|
while (1) {
|
2005-04-17 00:20:36 +02:00
|
|
|
l = strcspn(str, "\"\\");
|
|
|
|
if (l) {
|
|
|
|
fwrite(str, l, 1, out);
|
2006-06-09 07:12:39 +02:00
|
|
|
str += l;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-06-09 07:12:39 +02:00
|
|
|
if (!*str)
|
|
|
|
break;
|
|
|
|
fprintf(out, "\\%c", *str++);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
fputs("\"\n", out);
|
|
|
|
break;
|
|
|
|
case S_HEX:
|
|
|
|
str = sym_get_string_value(sym);
|
|
|
|
if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
|
|
|
|
fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case S_INT:
|
|
|
|
str = sym_get_string_value(sym);
|
|
|
|
fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
next:
|
|
|
|
if (menu->list) {
|
|
|
|
menu = menu->list;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (menu->next)
|
|
|
|
menu = menu->next;
|
|
|
|
else while ((menu = menu->parent)) {
|
|
|
|
if (menu->next) {
|
|
|
|
menu = menu->next;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(out);
|
2006-06-09 07:12:51 +02:00
|
|
|
|
|
|
|
if (*tmpname) {
|
|
|
|
strcat(dirname, name ? name : conf_get_configname());
|
|
|
|
strcat(dirname, ".old");
|
|
|
|
rename(newname, dirname);
|
|
|
|
if (rename(tmpname, newname))
|
|
|
|
return 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-06-09 07:12:38 +02:00
|
|
|
printf(_("#\n"
|
|
|
|
"# configuration written to %s\n"
|
2006-06-09 07:12:51 +02:00
|
|
|
"#\n"), newname);
|
2006-06-09 07:12:38 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
sym_change_count = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2006-06-09 07:12:39 +02:00
|
|
|
|
2006-06-09 07:12:42 +02:00
|
|
|
int conf_split_config(void)
|
|
|
|
{
|
|
|
|
char *name, path[128];
|
|
|
|
char *s, *d, c;
|
|
|
|
struct symbol *sym;
|
|
|
|
struct stat sb;
|
|
|
|
int res, i, fd;
|
|
|
|
|
|
|
|
name = getenv("KCONFIG_AUTOCONFIG");
|
|
|
|
if (!name)
|
|
|
|
name = "include/config/auto.conf";
|
|
|
|
conf_read_simple(name, S_DEF_AUTO);
|
|
|
|
|
|
|
|
if (chdir("include/config"))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
res = 0;
|
|
|
|
for_all_symbols(i, sym) {
|
|
|
|
sym_calc_value(sym);
|
|
|
|
if ((sym->flags & SYMBOL_AUTO) || !sym->name)
|
|
|
|
continue;
|
|
|
|
if (sym->flags & SYMBOL_WRITE) {
|
|
|
|
if (sym->flags & SYMBOL_DEF_AUTO) {
|
|
|
|
/*
|
|
|
|
* symbol has old and new value,
|
|
|
|
* so compare them...
|
|
|
|
*/
|
|
|
|
switch (sym->type) {
|
|
|
|
case S_BOOLEAN:
|
|
|
|
case S_TRISTATE:
|
|
|
|
if (sym_get_tristate_value(sym) ==
|
|
|
|
sym->def[S_DEF_AUTO].tri)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
case S_STRING:
|
|
|
|
case S_HEX:
|
|
|
|
case S_INT:
|
|
|
|
if (!strcmp(sym_get_string_value(sym),
|
|
|
|
sym->def[S_DEF_AUTO].val))
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If there is no old value, only 'no' (unset)
|
|
|
|
* is allowed as new value.
|
|
|
|
*/
|
|
|
|
switch (sym->type) {
|
|
|
|
case S_BOOLEAN:
|
|
|
|
case S_TRISTATE:
|
|
|
|
if (sym_get_tristate_value(sym) == no)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (!(sym->flags & SYMBOL_DEF_AUTO))
|
|
|
|
/* There is neither an old nor a new value. */
|
|
|
|
continue;
|
|
|
|
/* else
|
|
|
|
* There is an old value, but no new value ('no' (unset)
|
|
|
|
* isn't saved in auto.conf, so the old value is always
|
|
|
|
* different from 'no').
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Replace all '_' and append ".h" */
|
|
|
|
s = sym->name;
|
|
|
|
d = path;
|
|
|
|
while ((c = *s++)) {
|
|
|
|
c = tolower(c);
|
|
|
|
*d++ = (c == '_') ? '/' : c;
|
|
|
|
}
|
|
|
|
strcpy(d, ".h");
|
|
|
|
|
|
|
|
/* Assume directory path already exists. */
|
|
|
|
fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
|
|
|
|
if (fd == -1) {
|
|
|
|
if (errno != ENOENT) {
|
|
|
|
res = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Create directory components,
|
|
|
|
* unless they exist already.
|
|
|
|
*/
|
|
|
|
d = path;
|
|
|
|
while ((d = strchr(d, '/'))) {
|
|
|
|
*d = 0;
|
|
|
|
if (stat(path, &sb) && mkdir(path, 0755)) {
|
|
|
|
res = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
*d++ = '/';
|
|
|
|
}
|
|
|
|
/* Try it again. */
|
|
|
|
fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
|
|
|
|
if (fd == -1) {
|
|
|
|
res = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
if (chdir("../.."))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2006-06-09 07:12:39 +02:00
|
|
|
int conf_write_autoconf(void)
|
|
|
|
{
|
|
|
|
struct symbol *sym;
|
|
|
|
const char *str;
|
|
|
|
char *name;
|
|
|
|
FILE *out, *out_h;
|
|
|
|
time_t now;
|
|
|
|
int i, l;
|
|
|
|
|
2006-06-09 07:12:42 +02:00
|
|
|
sym_clear_all_valid();
|
|
|
|
|
2006-06-09 07:12:39 +02:00
|
|
|
file_write_dep("include/config/auto.conf.cmd");
|
|
|
|
|
2006-06-09 07:12:42 +02:00
|
|
|
if (conf_split_config())
|
|
|
|
return 1;
|
|
|
|
|
2006-06-09 07:12:39 +02:00
|
|
|
out = fopen(".tmpconfig", "w");
|
|
|
|
if (!out)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
out_h = fopen(".tmpconfig.h", "w");
|
|
|
|
if (!out_h) {
|
|
|
|
fclose(out);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
sym = sym_lookup("KERNELVERSION", 0);
|
|
|
|
sym_calc_value(sym);
|
|
|
|
time(&now);
|
|
|
|
fprintf(out, "#\n"
|
|
|
|
"# Automatically generated make config: don't edit\n"
|
|
|
|
"# Linux kernel version: %s\n"
|
|
|
|
"# %s"
|
|
|
|
"#\n",
|
|
|
|
sym_get_string_value(sym), ctime(&now));
|
|
|
|
fprintf(out_h, "/*\n"
|
|
|
|
" * Automatically generated C config: don't edit\n"
|
|
|
|
" * Linux kernel version: %s\n"
|
|
|
|
" * %s"
|
|
|
|
" */\n"
|
|
|
|
"#define AUTOCONF_INCLUDED\n",
|
|
|
|
sym_get_string_value(sym), ctime(&now));
|
|
|
|
|
|
|
|
for_all_symbols(i, sym) {
|
|
|
|
sym_calc_value(sym);
|
|
|
|
if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
|
|
|
|
continue;
|
|
|
|
switch (sym->type) {
|
|
|
|
case S_BOOLEAN:
|
|
|
|
case S_TRISTATE:
|
|
|
|
switch (sym_get_tristate_value(sym)) {
|
|
|
|
case no:
|
|
|
|
break;
|
|
|
|
case mod:
|
|
|
|
fprintf(out, "CONFIG_%s=m\n", sym->name);
|
|
|
|
fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
|
|
|
|
break;
|
|
|
|
case yes:
|
|
|
|
fprintf(out, "CONFIG_%s=y\n", sym->name);
|
|
|
|
fprintf(out_h, "#define CONFIG_%s 1\n", sym->name);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case S_STRING:
|
|
|
|
str = sym_get_string_value(sym);
|
|
|
|
fprintf(out, "CONFIG_%s=\"", sym->name);
|
|
|
|
fprintf(out_h, "#define CONFIG_%s \"", sym->name);
|
|
|
|
while (1) {
|
|
|
|
l = strcspn(str, "\"\\");
|
|
|
|
if (l) {
|
|
|
|
fwrite(str, l, 1, out);
|
|
|
|
fwrite(str, l, 1, out_h);
|
|
|
|
str += l;
|
|
|
|
}
|
|
|
|
if (!*str)
|
|
|
|
break;
|
|
|
|
fprintf(out, "\\%c", *str);
|
|
|
|
fprintf(out_h, "\\%c", *str);
|
|
|
|
str++;
|
|
|
|
}
|
|
|
|
fputs("\"\n", out);
|
|
|
|
fputs("\"\n", out_h);
|
|
|
|
break;
|
|
|
|
case S_HEX:
|
|
|
|
str = sym_get_string_value(sym);
|
|
|
|
if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
|
|
|
|
fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
|
|
|
|
fprintf(out_h, "#define CONFIG_%s 0x%s\n", sym->name, str);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case S_INT:
|
|
|
|
str = sym_get_string_value(sym);
|
|
|
|
fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
|
|
|
|
fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(out);
|
|
|
|
fclose(out_h);
|
|
|
|
|
|
|
|
name = getenv("KCONFIG_AUTOHEADER");
|
|
|
|
if (!name)
|
|
|
|
name = "include/linux/autoconf.h";
|
|
|
|
if (rename(".tmpconfig.h", name))
|
|
|
|
return 1;
|
|
|
|
name = getenv("KCONFIG_AUTOCONFIG");
|
|
|
|
if (!name)
|
|
|
|
name = "include/config/auto.conf";
|
|
|
|
/*
|
|
|
|
* This must be the last step, kbuild has a dependency on auto.conf
|
|
|
|
* and this marks the successful completion of the previous steps.
|
|
|
|
*/
|
|
|
|
if (rename(".tmpconfig", name))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|