__slots__ = (

"_encoding",

"_functions",

"_set_match",

"_srctree_prefix",

"_unset_match",

"_warn_assign_no_prompt",

"choices",

"comments",

"config_header",

"config_prefix",

"const_syms",

"defconfig_list",

"defined_syms",

"env_vars",

"header_header",

"kconfig_filenames",

"m",

"menus",

"missing_syms",

"modules",

"n",

"named_choices",

"srctree",

"syms",

"top_node",

"unique_choices",

"unique_defined_syms",

"variables",

"warn",

"warn_assign_override",

"warn_assign_redun",

"warn_assign_undef",

"warn_to_stderr",

"warnings",

"y",

# Parsing-related

"_parsing_kconfigs",

"_readline",

"filename",

"linenr",

"_include_path",

"_filestack",

"_line",

"_tokens",

"_tokens_i",

"_reuse_tokens",

)

#

# Public interface

#

def __init__(self, filename="Kconfig", warn=True, warn_to_stderr=True,

encoding="utf-8", suppress_traceback=False):

"""

try:

self._init(filename, warn, warn_to_stderr, encoding)

except (EnvironmentError, KconfigError) as e:

if suppress_traceback:

cmd = sys.argv[0] # Empty string if missing

if cmd:

cmd += ": "

# Some long exception messages have extra newlines for better

# formatting when reported as an unhandled exception. Strip

# them here.

sys.exit(cmd + str(e).strip())

raise

def _init(self, filename, warn, warn_to_stderr, encoding):

# See __init__()

self._encoding = encoding

self.srctree = os.getenv("srctree", "")

# A prefix we can reliably strip from glob() results to get a filename

# relative to $srctree. relpath() can cause issues for symlinks,

# because it assumes symlink/../foo is the same as foo/.

self._srctree_prefix = realpath(self.srctree) + os.sep

self.warn = warn

self.warn_to_stderr = warn_to_stderr

self.warn_assign_undef = os.getenv("KCONFIG_WARN_UNDEF_ASSIGN") == "y"

self.warn_assign_override = True

self.warn_assign_redun = True

self._warn_assign_no_prompt = True

self.warnings = []

self.config_prefix = os.getenv("CONFIG_", "CONFIG_")

# Regular expressions for parsing .config files

self._set_match = _re_match(self.config_prefix + r"([^=]+)=(.*)")

self._unset_match = _re_match(r"# {}([^ ]+) is not set".format(

self.config_prefix))

self.config_header = os.getenv("KCONFIG_CONFIG_HEADER", "")

self.header_header = os.getenv("KCONFIG_AUTOHEADER_HEADER", "")

self.syms = {}

self.const_syms = {}

self.defined_syms = []

self.missing_syms = []

self.named_choices = {}

self.choices = []

self.menus = []

self.comments = []

for nmy in "n", "m", "y":

sym = Symbol()

sym.kconfig = self

sym.name = nmy

sym.is_constant = True

sym.orig_type = TRISTATE

sym._cached_tri_val = STR_TO_TRI[nmy]

self.const_syms[nmy] = sym

self.n = self.const_syms["n"]

self.m = self.const_syms["m"]

self.y = self.const_syms["y"]

# Make n/m/y well-formed symbols

for nmy in "n", "m", "y":

sym = self.const_syms[nmy]

sym.rev_dep = sym.weak_rev_dep = sym.direct_dep = self.n

# Maps preprocessor variables names to Variable instances

self.variables = {}

# Predefined preprocessor functions, with min/max number of arguments

self._functions = {

"info": (_info_fn, 1, 1),

"error-if": (_error_if_fn, 2, 2),

"filename": (_filename_fn, 0, 0),

"lineno": (_lineno_fn, 0, 0),

"shell": (_shell_fn, 1, 1),

"warning-if": (_warning_if_fn, 2, 2),

}

# Add any user-defined preprocessor functions

try:

self._functions.update(

importlib.import_module(

os.getenv("KCONFIG_FUNCTIONS", "kconfigfunctions")

).functions)

except ImportError:

pass

# This determines whether previously unseen symbols are registered.

# They shouldn't be if we parse expressions after parsing, as part of

# Kconfig.eval_string().

self._parsing_kconfigs = True

self.modules = self._lookup_sym("MODULES")

self.defconfig_list = None

self.top_node = MenuNode()

self.top_node.kconfig = self

self.top_node.item = MENU

self.top_node.is_menuconfig = True

self.top_node.visibility = self.y

self.top_node.prompt = ("Main menu", self.y)

self.top_node.parent = None

self.top_node.dep = self.y

self.top_node.filename = filename

self.top_node.linenr = 1

self.top_node.include_path = ()

# Parse the Kconfig files

# Not used internally. Provided as a convenience.

self.kconfig_filenames = [filename]

self.env_vars = set()

# Keeps track of the location in the parent Kconfig files. Kconfig

# files usually source other Kconfig files. See _enter_file().

self._filestack = []

self._include_path = ()

# The current parsing location

self.filename = filename

self.linenr = 0

# Used to avoid retokenizing lines when we discover that they're not

# part of the construct currently being parsed. This is kinda like an

# unget operation.

self._reuse_tokens = False

# Open the top-level Kconfig file. Store the readline() method directly

# as a small optimization.

self._readline = self._open(join(self.srctree, filename), "r").readline

try:

# Parse the Kconfig files. Returns the last node, which we

# terminate with '.next = None'.

self._parse_block(None, self.top_node, self.top_node).next = None

self.top_node.list = self.top_node.next

self.top_node.next = None

except UnicodeDecodeError as e:

_decoding_error(e, self.filename)

# Close the top-level Kconfig file. __self__ fetches the 'file' object

# for the method.

self._readline.__self__.close()

self._parsing_kconfigs = False

# Do various menu tree post-processing

self._finalize_node(self.top_node, self.y)

self.unique_defined_syms = _ordered_unique(self.defined_syms)

self.unique_choices = _ordered_unique(self.choices)

# Do sanity checks. Some of these depend on everything being finalized.

self._check_sym_sanity()

self._check_choice_sanity()

# KCONFIG_STRICT is an older alias for KCONFIG_WARN_UNDEF, supported

# for backwards compatibility

if os.getenv("KCONFIG_WARN_UNDEF") == "y" or \

os.getenv("KCONFIG_STRICT") == "y":

self._check_undef_syms()

# Build Symbol._dependents for all symbols and choices

self._build_dep()

# Check for dependency loops

check_dep_loop_sym = _check_dep_loop_sym # Micro-optimization

for sym in self.unique_defined_syms:

check_dep_loop_sym(sym, False)

# Add extra dependencies from choices to choice symbols that get

# awkward during dependency loop detection

self._add_choice_deps()

@property

def mainmenu_text(self):

"""

return self.top_node.prompt[0]

@property

def defconfig_filename(self):

"""

if self.defconfig_list:

for filename, cond in self.defconfig_list.defaults:

if expr_value(cond):

try:

with self._open_config(filename.str_value) as f:

return f.name

except EnvironmentError:

continue

return None

def load_config(self, filename=None, replace=True, verbose=None):

"""

if verbose is not None:

_warn_verbose_deprecated("load_config")

msg = None

if filename is None:

filename = standard_config_filename()

if not exists(filename) and \

not exists(join(self.srctree, filename)):

defconfig = self.defconfig_filename

if defconfig is None:

return "Using default symbol values (no '{}')" \

.format(filename)

msg = " default configuration '{}' (no '{}')" \

.format(defconfig, filename)

filename = defconfig

if not msg:

msg = " configuration '{}'".format(filename)

# Disable the warning about assigning to symbols without prompts. This

# is normal and expected within a .config file.

self._warn_assign_no_prompt = False

# This stub only exists to make sure _warn_assign_no_prompt gets

# reenabled

try:

self._load_config(filename, replace)

except UnicodeDecodeError as e:

_decoding_error(e, filename)

finally:

self._warn_assign_no_prompt = True

return ("Loaded" if replace else "Merged") + msg

def _load_config(self, filename, replace):

with self._open_config(filename) as f:

if replace:

self.missing_syms = []

# If we're replacing the configuration, keep track of which

# symbols and choices got set so that we can unset the rest

# later. This avoids invalidating everything and is faster.

# Another benefit is that invalidation must be rock solid for

# it to work, making it a good test.

for sym in self.unique_defined_syms:

sym._was_set = False

for choice in self.unique_choices:

choice._was_set = False

# Small optimizations

set_match = self._set_match

unset_match = self._unset_match

get_sym = self.syms.get

for linenr, line in enumerate(f, 1):

# The C tools ignore trailing whitespace

line = line.rstrip()

match = set_match(line)

if match:

name, val = match.groups()

sym = get_sym(name)

if not sym or not sym.nodes:

self._undef_assign(name, val, filename, linenr)

continue

if sym.orig_type in _BOOL_TRISTATE:

# The C implementation only checks the first character

# to the right of '=', for whatever reason

if not (sym.orig_type is BOOL

and val.startswith(("y", "n")) or

sym.orig_type is TRISTATE

and val.startswith(("y", "m", "n"))):

self._warn("'{}' is not a valid value for the {} "

"symbol {}. Assignment ignored."

.format(val, TYPE_TO_STR[sym.orig_type],

sym.name_and_loc),

filename, linenr)

continue

val = val[0]

if sym.choice and val != "n":

# During .config loading, we infer the mode of the

# choice from the kind of values that are assigned

# to the choice symbols

prev_mode = sym.choice.user_value

if prev_mode is not None and \

TRI_TO_STR[prev_mode] != val:

self._warn("both m and y assigned to symbols "

"within the same choice",

filename, linenr)

# Set the choice's mode

sym.choice.set_value(val)

elif sym.orig_type is STRING:

match = _conf_string_match(val)

if not match:

self._warn("malformed string literal in "

"assignment to {}. Assignment ignored."

.format(sym.name_and_loc),

filename, linenr)

continue

val = unescape(match.group(1))

else:

match = unset_match(line)

if not match:

# Print a warning for lines that match neither

# set_match() nor unset_match() and that are not blank

# lines or comments. 'line' has already been

# rstrip()'d, so blank lines show up as "" here.

if line and not line.lstrip().startswith("#"):

self._warn("ignoring malformed line '{}'"

.format(line),

filename, linenr)

continue

name = match.group(1)

sym = get_sym(name)

if not sym or not sym.nodes:

self._undef_assign(name, "n", filename, linenr)

continue

if sym.orig_type not in _BOOL_TRISTATE:

continue

val = "n"

# Done parsing the assignment. Set the value.

if sym._was_set:

self._assigned_twice(sym, val, filename, linenr)

sym.set_value(val)

if replace:

# If we're replacing the configuration, unset the symbols that

# didn't get set

for sym in self.unique_defined_syms:

if not sym._was_set:

sym.unset_value()

for choice in self.unique_choices:

if not choice._was_set:

choice.unset_value()

def _undef_assign(self, name, val, filename, linenr):

# Called for assignments to undefined symbols during .config loading

self.missing_syms.append((name, val))

if self.warn_assign_undef:

self._warn(

"attempt to assign the value '{}' to the undefined symbol {}"

.format(val, name), filename, linenr)

def _assigned_twice(self, sym, new_val, filename, linenr):

# Called when a symbol is assigned more than once in a .config file

# Use strings for bool/tristate user values in the warning

if sym.orig_type in _BOOL_TRISTATE:

user_val = TRI_TO_STR[sym.user_value]

else:

user_val = sym.user_value

msg = '{} set more than once. Old value "{}", new value "{}".'.format(

sym.name_and_loc, user_val, new_val)

if user_val == new_val:

if self.warn_assign_redun:

self._warn(msg, filename, linenr)

elif self.warn_assign_override:

self._warn(msg, filename, linenr)

def load_allconfig(self, filename):

"""

load_allconfig(self, filename)

def write_autoconf(self, filename=None, header=None):

r"""

if filename is None:

filename = os.getenv("KCONFIG_AUTOHEADER",

"include/generated/autoconf.h")

if self._write_if_changed(filename, self._autoconf_contents(header)):

return "Kconfig header saved to '{}'".format(filename)

return "No change to Kconfig header in '{}'".format(filename)

def _autoconf_contents(self, header):

# write_autoconf() helper. Returns the contents to write as a string,

# with 'header' or KCONFIG_AUTOHEADER_HEADER at the beginning.

if header is None:

header = self.header_header

chunks = [header] # "".join()ed later

add = chunks.append

for sym in self.unique_defined_syms:

# _write_to_conf is determined when the value is calculated. This

# is a hidden function call due to property magic.

#

# Note: In client code, you can check if sym.config_string is empty

# instead, to avoid accessing the internal _write_to_conf variable

# (though it's likely to keep working).

val = sym.str_value

if not sym._write_to_conf:

continue

if sym.orig_type in _BOOL_TRISTATE:

if val == "y":

add("#define {}{} 1\n"

.format(self.config_prefix, sym.name))

elif val == "m":

add("#define {}{}_MODULE 1\n"

.format(self.config_prefix, sym.name))

elif val == "n":

add("#define {}{} 0\n"

.format(self.config_prefix, sym.name))

elif sym.orig_type is STRING:

add('#define {}{} "{}"\n'

.format(self.config_prefix, sym.name, escape(val)))

else: # sym.orig_type in _INT_HEX:

if sym.orig_type is HEX and \

not val.startswith(("0x", "0X")):

val = "0x" + val

add("#define {}{} {}\n"

.format(self.config_prefix, sym.name, val))

return "".join(chunks)

def _config_mk_write(self, header):

if header is None:

header = self.header_header

chunks = [header] # "".join()ed later

add = chunks.append

for sym in self.unique_defined_syms:

# _write_to_conf is determined when the value is calculated. This

# is a hidden function call due to property magic.

#

# Note: In client code, you can check if sym.config_string is empty

# instead, to avoid accessing the internal _write_to_conf variable

# (though it's likely to keep working).

val = sym.str_value

if not sym._write_to_conf:

continue

if sym.orig_type in _BOOL_TRISTATE:

if val == "y":

add("{}{}=1\n".format(self.config_prefix, sym.name))

elif val == "n":

add("{}{}=0\n".format(self.config_prefix, sym.name))

elif sym.orig_type is STRING:

add('{}{}="{}"\n'

.format(self.config_prefix, sym.name, escape(val)))

return "".join(chunks)

def write_config(self, filename=None, header=None, save_old=True,

verbose=None):

r"""

if verbose is not None:

_warn_verbose_deprecated("write_config")

if filename is None:

filename = standard_config_filename()

contents = self._config_contents(header)

if self._contents_eq(filename, contents):

return "No change to configuration in '{}'".format(filename)

if save_old:

_save_old(filename)

with self._open(filename, "w") as f:

f.write(contents)

# write the autoconf file

self.write_autoconf('include/fpvm/config.h')

if self._write_if_changed('config.mk', self._config_mk_write(header)):

return "config.mk saved".format(filename)

return "Configuration saved to '{}'".format(filename)

def _config_contents(self, header):

# write_config() helper. Returns the contents to write as a string,

# with 'header' or KCONFIG_CONFIG_HEADER at the beginning.

#

# More memory friendly would be to 'yield' the strings and

# "".join(_config_contents()), but it was a bit slower on my system.

# node_iter() was used here before commit 3aea9f7 ("Add '# end of

# <menu>' after menus in .config"). Those comments get tricky to

# implement with it.

for sym in self.unique_defined_syms:

sym._visited = False

if header is None:

header = self.config_header

chunks = [header] # "".join()ed later

add = chunks.append

# Did we just print an '# end of ...' comment?

after_end_comment = False

node = self.top_node

while 1:

# Jump to the next node with an iterative tree walk

if node.list:

node = node.list

elif node.next:

node = node.next

else:

while node.parent:

node = node.parent

# Add a comment when leaving visible menus

if node.item is MENU and expr_value(node.dep) and \

expr_value(node.visibility) and \

node is not self.top_node:

add("# end of {}\n".format(node.prompt[0]))

after_end_comment = True

if node.next:

node = node.next

break

else:

# No more nodes

return "".join(chunks)

# Generate configuration output for the node

item = node.item

if item.__class__ is Symbol:

if item._visited:

continue

item._visited = True

conf_string = item.config_string

if not conf_string:

continue

if after_end_comment:

# Add a blank line before the first symbol printed after an

# '# end of ...' comment

after_end_comment = False

add("\n")

add(conf_string)

elif expr_value(node.dep) and \

((item is MENU and expr_value(node.visibility)) or

item is COMMENT):

add("\n#\n# {}\n#\n".format(node.prompt[0]))

after_end_comment = False

def write_min_config(self, filename, header=None):

"""

if self._write_if_changed(filename, self._min_config_contents(header)):

return "Minimal configuration saved to '{}'".format(filename)

return "No change to minimal configuration in '{}'".format(filename)

def _min_config_contents(self, header):

# write_min_config() helper. Returns the contents to write as a string,

# with 'header' or KCONFIG_CONFIG_HEADER at the beginning.

if header is None:

header = self.config_header

chunks = [header] # "".join()ed later

add = chunks.append

for sym in self.unique_defined_syms:

# Skip symbols that cannot be changed. Only check

# non-choice symbols, as selects don't affect choice

# symbols.

if not sym.choice and \

sym.visibility <= expr_value(sym.rev_dep):

continue

# Skip symbols whose value matches their default

if sym.str_value == sym._str_default():

continue

# Skip symbols that would be selected by default in a

# choice, unless the choice is optional or the symbol type

# isn't bool (it might be possible to set the choice mode

# to n or the symbol to m in those cases).

if sym.choice and \