def mconfig(argv):
kconfig = os.path.join("tools", "menuconfig", "extra", "Configs",
"Config.in")
display_style = "default selection=fg:white,bg:blue"
target_conf = os.path.join(".config")
header = "# Generated by Huawei LiteOS Kconfig Tool"
mconf_set_env(display_style, target_conf, header)
kconf = Kconfig(filename=kconfig)
if len(argv) == 2 and argv[1] == 'savemenuconfig':
kconf.load_config()
print(kconf.write_config()) # savemenuconfig
elif len(argv) == 2 and argv[1] == 'defconfig':
kconf.load_allconfig("alldef.config")
print(kconf.write_config()) # defconfig
elif len(argv) == 2 and argv[1] == 'allyesconfig':
kconf.warn = False
for sym in kconf.unique_defined_syms:
sym.set_value(1 if sym.choice else 2)
for choice in kconf.unique_choices:
choice.set_value(2)
kconf.warn = True
kconf.load_allconfig("allyes.config")
print(kconf.write_config()) # allyesconfig
elif len(argv) == 2 and argv[1] == 'allnoconfig':
kconf.warn = False
for sym in kconf.unique_defined_syms:
sym.set_value(2 if sym.is_allnoconfig_y else 0)
kconf.warn = True
kconf.load_allconfig("allno.config")
print(kconf.write_config()) # allnoconfig
else:
menuconfig(kconf) # menuconfig
kconf.write_autoconf()
def defconfig_merge(
kconf: kconfiglib.Kconfig,
sources: T.List[pathlib.Path],
fail_on_unknown: bool,
) -> GenerationResult:
for path in sources:
kconf.load_config(str(path.absolute()), replace=False)
if kconf.missing_syms and fail_on_unknown:
raise ValueError("Unknown symbols: {}".format(kconf.missing_syms))
stats = Stats(
nb_symbols=len([
symbol for symbol in kconf.unique_defined_syms if symbol.user_value
]),
files=sources,
)
with tempfile.NamedTemporaryFile(mode='r') as f:
kconf.write_min_config(f.name, header='')
lines = f.read()
return GenerationResult(
stats=stats,
output=lines,
)
def main():
parse_args()
print("Parsing Kconfig tree in {}".format(args.kconfig_root))
kconf = Kconfig(args.kconfig_root, warn_to_stderr=False)
# Enable warnings for assignments to undefined symbols
kconf.enable_undef_warnings()
# This script uses alldefconfig as the base. Other starting states could be set
# up here as well. The approach in examples/allnoconfig_simpler.py could
# provide an allnoconfig starting state for example.
print("Using {} as base".format(args.conf_fragments[0]))
for config in args.conf_fragments[1:]:
print("Merging {}".format(config))
# Create a merged configuration by loading the fragments with replace=False
for config in args.conf_fragments:
kconf.load_config(config, replace=False)
# Write the merged configuration and the C header. This will evaluate all
# symbols, which might generate additional warnings, so do it before
# checking for warnings.
kconf.write_config(args.dotconfig)
kconf.write_autoconf(args.autoconf)
# Print warnings for symbols whose actual value doesn't match the assigned
# value
for sym in kconf.defined_syms:
# Was the symbol assigned to? Choice symbols are checked separately.
if sym.user_value is not None and not sym.choice:
verify_assigned_sym_value(sym)
# Print warnings for choices whose actual selection doesn't match the user
# selection
for choice in kconf.choices:
if choice.user_selection:
verify_assigned_choice_value(choice)
# We could roll this into the loop below, but it's nice to always print all
# warnings, even if one of them turns out to be fatal
for warning in kconf.warnings:
if enabled(warning):
print(warning, file=sys.stderr)
# Turn all warnings except for explicity whitelisted ones into errors. In
# particular, this will turn assignments to undefined Kconfig variables
# into errors.
#
# A warning is generated by this script whenever a symbol gets a different
# value than the one it was assigned. Keep that one as just a warning for
# now as well.
for warning in kconf.warnings:
if fatal(warning):
sys.exit("Error: Aborting due to non-whitelisted Kconfig "
"warning '{}'.\nNote: If this warning doesn't point "
"to an actual problem, you can add it to the "
"whitelist at the top of {}.".format(
warning, sys.argv[0]))
def defconfig_split(
kconf: kconfiglib.Kconfig,
fail_on_unknown: bool,
categories: T.List[T.Text],
destdir: pathlib.Path,
source: T.TextIO,
prefix: T.Text,
) -> Stats:
with tempfile.TemporaryDirectory() as d:
config_path = os.path.join(d, '.config')
defconfig_path = os.path.join(d, 'defconfig')
with open(config_path, 'w', encoding='utf-8') as f:
for line in source:
f.write(line)
kconf.load_config(config_path)
if fail_on_unknown and kconf.missing_syms:
raise ValueError("Unknown symbols: {}".format(kconf.missing_syms))
kconf.write_min_config(defconfig_path)
kconf.load_config(defconfig_path)
symbols_by_category: T.Dict[T.Text, T.List[kconfiglib.Symbol]] = {
cat: []
for cat in categories
}
symbols_by_category[''] = []
for symbol in kconf.unique_defined_syms:
if symbol.user_value is not None:
category = max(cat for cat in symbols_by_category
if symbol.nodes[0].filename.startswith(cat))
symbols_by_category[category].append(symbol)
stats = Stats(
nb_symbols=sum(
len(symbols) for symbols in symbols_by_category.values()),
files=[],
)
for category, symbols in sorted(symbols_by_category.items()):
if category:
path = destdir / '{}.{}'.format(prefix, category.replace('/', '_'))
else:
path = destdir / prefix
stats.files.append(path)
with path.open('w', encoding='utf-8') as output:
for symbol in symbols:
output.write(symbol.config_string)
return stats
def main():
parser = argparse.ArgumentParser(description="Merge .config files.")
parser.add_argument("--outfile", required=True)
parser.add_argument("config_files", nargs="+")
args = parser.parse_args()
config = Kconfig("Kconfig")
config.warn_assign_override = False
config.warn_assign_redun = False
for config_file in args.config_files:
config.load_config(config_file, replace=False)
config.write_config(args.outfile)
def main():
kconf = Kconfig(KCONFIG_FILE, warn=False)
kconf.load_config(DEFCONFIG)
if sys.argv[1] == "GDB_INTERNAL":
try:
for opt in open("../config_append", "r").readlines():
enable_opt(kconf, opt)
except:
pass
set_debug(kconf)
disable_opt(kconf, 'SMP')
# enable_opt(kconf, 'BLK_DEV_INITRD')
# enable_opt(kconf, 'BLK_DEV_RAM')
kconf.write_config(CONFIG_FILE)
def main(kconfig_file, config1, config2):
kconf = Kconfig(kconfig_file, suppress_traceback=True)
# Enable warnings for assignments to undefined symbols
kconf.warn_assign_undef = False
# (This script uses alldefconfig as the base. Other starting states could be
# set up here as well. The approach in examples/allnoconfig_simpler.py could
# provide an allnoconfig starting state for example.)
# Disable warnings generated for multiple assignments to the same symbol within
# a (set of) configuration files. Assigning a symbol multiple times might be
# done intentionally when merging configuration files.
kconf.warn_assign_override = False
kconf.warn_assign_redun = False
# Create a merged configuration by loading the fragments with replace=False.
# load_config() and write_config() returns a message to print.
print(kconf.load_config(config1, replace=False))
print(kconf.load_config(config2, replace=False))
# Modification for PX4 unset all symbols (INT,HEX etc) from 2nd config
f = open(config2, 'r')
unset_match = re.compile(r"# {}([^ ]+) is not set".format("CONFIG_"),
re.ASCII).match
for line in f:
match = unset_match(line)
#pprint.pprint(match)
if match is not None:
sym_name = match.group(1)
kconf.syms[sym_name].unset_value()
f.close()
# Print warnings for symbols whose actual value doesn't match the assigned
# value
for sym in kconf.defined_syms:
# Was the symbol assigned to?
if sym.user_value is not None:
# Tristate values are represented as 0, 1, 2. Having them as
# "n", "m", "y" is more convenient here, so convert.
if sym.type in (BOOL, TRISTATE):
user_value = TRI_TO_STR[sym.user_value]
else:
user_value = sym.user_value
if user_value != sym.str_value:
print("warning: {} was assigned the value '{}' but got the "
"value '{}' -- check dependencies".format(
sym.name_and_loc, user_value, sym.str_value),
file=sys.stderr)
return kconf
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description=__doc__)
parser.add_argument("--show-help",
"-l",
action="store_true",
help="Show any help texts as well")
parser.add_argument("kconfig",
metavar="KCONFIG",
nargs="?",
default="Kconfig",
help="Top-level Kconfig file (default: Kconfig)")
args = parser.parse_args()
kconf = Kconfig(args.kconfig, suppress_traceback=True)
# Make it possible to filter this message out
print(kconf.load_config(), file=sys.stderr)
for sym in kconf.unique_defined_syms:
# Only show symbols that can be toggled. Choice symbols are a special
# case in that sym.assignable will be (2,) (length 1) for visible
# symbols in choices in y mode, but they can still be toggled by
# selecting some other symbol.
if sym.user_value is None and \
(len(sym.assignable) > 1 or
(sym.visibility and (sym.orig_type in (INT, HEX, STRING) or
sym.choice))):
# Don't reuse the 'config_string' format for bool/tristate symbols,
# to show n-valued symbols as 'CONFIG_FOO=n' instead of
# '# CONFIG_FOO is not set'. This matches the C tools.
if sym.orig_type in (BOOL, TRISTATE):
s = "{}{}={}\n".format(kconf.config_prefix, sym.name,
TRI_TO_STR[sym.tri_value])
else:
s = sym.config_string
print(s, end="")
if args.show_help:
for node in sym.nodes:
if node.help is not None:
# Indent by two spaces. textwrap.indent() is not
# available in Python 2 (it's 3.3+).
print("\n".join(" " + line
for line in node.help.split("\n")))
break
def get_kconfig ():
global kconfig
if kconfig:
return kconfig
project = get_project ()
if not project:
return None
os.environ.setdefault ("KCONFIG_CONFIG", "config/kconfig.mk")
kconfig = Kconfig ("kconfig")
kconfig.disable_redun_warnings ()
kconfig.disable_override_warnings ()
# load project kconfig.mk
if os.path.isfile ("config/kconfig.mk"):
kconfig.load_config ("config/kconfig.mk", False)
else:
soc_common = os.path.join (project ["soc_dir"], "soc.config")
if os.path.isfile (soc_common):
kconfig.load_config (soc_common, False)
# load soc.config
soc_config = project ["soc_cfg"]
kconfig.load_config (soc_config, False)
# load bsp.config
bsp_config = os.path.join (project ["bsp_dir"], "bsp.config")
if os.path.isfile (bsp_config):
kconfig.load_config (bsp_config, False)
return kconfig
if not conf_changed:
break
def do_oldconfig_rec(node):
while node:
do_oldconfig_for_node(node)
if node.list:
do_oldconfig_rec(node.list)
node = node.next
if __name__ == "__main__":
if len(sys.argv) != 2:
eprint("error: pass name of base Kconfig file as argument")
sys.exit(1)
if not os.path.exists(".config"):
eprint("error: no existing .config")
sys.exit(1)
kconf = Kconfig(sys.argv[1])
kconf.load_config(".config")
do_oldconfig(kconf)
kconf.write_config(".config")
print("Configuration written to .config")
kconf.warn_assign_undef = True
# (This script uses alldefconfig as the base. Other starting states could be
# set up here as well. The approach in examples/allnoconfig_simpler.py could
# provide an allnoconfig starting state for example.)
# Disable warnings generated for multiple assignments to the same symbol within
# a (set of) configuration files. Assigning a symbol multiple times might be
# done intentionally when merging configuration files.
kconf.warn_assign_override = False
kconf.warn_assign_redun = False
# Create a merged configuration by loading the fragments with replace=False.
# load_config() and write_config() returns a message to print.
for config in sys.argv[3:]:
print(kconf.load_config(config, replace=False))
# Write the merged configuration
print(kconf.write_config(sys.argv[2]))
# Print warnings for symbols whose actual value doesn't match the assigned
# value
for sym in kconf.defined_syms:
# Was the symbol assigned to?
if sym.user_value is not None:
# Tristate values are represented as 0, 1, 2. Having them as
# "n", "m", "y" is more convenient here, so convert.
if sym.type in (BOOL, TRISTATE):
user_value = TRI_TO_STR[sym.user_value]
else:
user_value = sym.user_value
# Print the initial configuration tree
print_menuconfig(kconf)
while True:
try:
cmd = input('Enter a symbol/choice name, "load_config", or "write_config" (or press CTRL+D to exit): ') \
.strip()
except EOFError:
print("")
break
if cmd == "load_config":
config_filename = input(".config file to load: ")
try:
kconf.load_config(config_filename)
except IOError as e:
# Print the (spammy) error from Kconfiglib itself
print(e.message + "\n")
else:
print("Configuration loaded from " + config_filename)
print_menuconfig(kconf)
continue
if cmd == "write_config":
config_filename = input("To this file: ")
try:
kconf.write_config(config_filename)
except IOError as e:
class MPConfig(TreeSelectionListener):
"""The MPConfig component initializes the KConfig library with the requested configuration,
and buildst the GUI, consisting of a "Load" and a "Save as" buttons, a search field, "show all"
checkbox, tree view and information text view."""
def __init__(self,
kconfig_file="Kconfig",
config_file=".config",
systemLogger=None):
"""[summary]
Parameters
----------
kconfig_file : string (default: "Kconfig")
The Kconfig configuration file
config_file : string (default: ".config")
The save file which will be used for loading and saving the settings
systemLogger (default: None)
A system logger object. If None then print statements are used for logging.
"""
global log
if systemLogger:
log = systemLogger
# Load Kconfig configuration files
self.kconfig = Kconfig(kconfig_file)
setKConfig(self.kconfig)
if os.path.isfile(config_file):
log.info(self.kconfig.load_config(config_file))
elif os.path.isfile(".config"):
log.info(self.kconfig.load_config(".config"))
self.tree = KConfigTree(self.kconfig)
self.tree.addTreeSelectionListener(self.treeSelectionChanged)
jTreeSP = JScrollPane(self.tree)
self.jta = JTextArea()
self.jta.setEditable(False)
jTextSP = JScrollPane(self.jta)
toolPanel = JPanel()
toolPanel.setLayout(BoxLayout(toolPanel, BoxLayout.X_AXIS))
toolPanel.setBorder(BorderFactory.createEmptyBorder(2, 0, 2, 0))
toolPanel.add(JLabel("Search: "))
jSearchPanel = JPanel()
jSearchPanel.setLayout(BoxLayout(jSearchPanel, BoxLayout.X_AXIS))
self.jSearchField = JTextField()
jSearchPanel.setBackground(self.jSearchField.getBackground())
jSearchPanel.setBorder(self.jSearchField.getBorder())
self.jSearchField.setBorder(None)
self.jSearchField.getDocument().addDocumentListener(
SearchListener(self.tree))
jSearchPanel.add(self.jSearchField)
clearSearchButton = JButton(u'\u00d7',
actionPerformed=self.clearSearch)
d = clearSearchButton.getPreferredSize()
clearSearchButton.setPreferredSize(Dimension(d.height, d.height))
clearSearchButton.setBackground(self.jSearchField.getBackground())
clearSearchButton.setBorder(None)
clearSearchButton.setOpaque(False)
clearSearchButton.setContentAreaFilled(False)
clearSearchButton.setFocusPainted(False)
jSearchPanel.add(clearSearchButton)
toolPanel.add(jSearchPanel)
self.showAllCheckBox = JCheckBox("Show all",
actionPerformed=self.OnShowAllCheck)
toolPanel.add(self.showAllCheckBox)
splitPane = JSplitPane(JSplitPane.VERTICAL_SPLIT, jTreeSP, jTextSP)
splitPane.setOneTouchExpandable(True)
splitPane.setDividerLocation(300)
treePanel = JPanel(BorderLayout())
treePanel.add(toolPanel, BorderLayout.NORTH)
treePanel.add(splitPane, BorderLayout.CENTER)
loadSavePanel = JPanel()
loadSavePanel.setLayout(BoxLayout(loadSavePanel, BoxLayout.X_AXIS))
loadSavePanel.add(
JButton("Load", actionPerformed=self.loadConfigDialog))
loadSavePanel.add(
JButton("Save as", actionPerformed=self.writeConfigDialog))
self.rootPanel = JPanel()
self.rootPanel.setLayout(BorderLayout())
self.rootPanel.add(loadSavePanel, BorderLayout.PAGE_START)
self.rootPanel.add(treePanel, BorderLayout.CENTER)
def clearSearch(self, event):
self.jSearchField.setText("")
def OnShowAllCheck(self, event):
self.tree.setShowAll(self.showAllCheckBox.isSelected())
self.tree.doSearch(self.jSearchField.getText()
) # Must repeat the search if one is active
def treeSelectionChanged(self, event):
"""When the user selects a new node in the tree, show info about the selected node
in the info text area below the tree."""
path = event.getNewLeadSelectionPath()
if path:
comp = path.getLastPathComponent()
if isinstance(comp, DefaultMutableTreeNode):
nodeData = comp.getUserObject()
if isinstance(nodeData, TreeNodeData):
self.jta.setText(getNodeInfoString(nodeData.knode))
self.jta.setCaretPosition(0)
def getPane(self):
"""Return the panel containing all the other components that is set up in __init__()."""
return self.rootPanel
def writeConfig(self, fileName):
"""Write the current configuration to the file specified."""
self.kconfig.write_config(fileName) # Save full configuration
#self.kconfig.write_min_config(fileName) # Save minimal configuration
def loadConfig(self, fileName):
"""Load configuration settings from the file specified."""
if os.path.isfile(fileName):
log.info(self.kconfig.load_config(fileName))
self.tree.createKconfShadowModel(self.kconfig)
self.tree.updateTree()
def writeConfigDialog(self, e):
"""Open a file dialog to save configuration"""
fileChooser = JFileChooser(os.getcwd())
retval = fileChooser.showSaveDialog(None)
if retval == JFileChooser.APPROVE_OPTION:
f = fileChooser.getSelectedFile()
self.writeConfig(f.getPath())
def loadConfigDialog(self, e):
"""Open a file dialog to select configuration to load"""
fileChooser = JFileChooser(os.getcwd())
retval = fileChooser.showOpenDialog(None)
if retval == JFileChooser.APPROVE_OPTION:
f = fileChooser.getSelectedFile()
log.info("Selected file: " + f.getPath())
self.loadConfig(f.getPath())
def main():
args = parse_args()
print("Parsing " + args.kconfig_file)
kconf = Kconfig(args.kconfig_file,
warn_to_stderr=False,
suppress_traceback=True)
if args.handwritten_input_configs:
# Warn for assignments to undefined symbols, but only for handwritten
# fragments, to avoid warnings-turned-errors when using an old
# configuration file together with updated Kconfig files
kconf.warn_assign_undef = True
# prj.conf may override settings from the board configuration, so
# disable warnings about symbols being assigned more than once
kconf.warn_assign_override = False
kconf.warn_assign_redun = False
# Load configuration files
print(kconf.load_config(args.configs_in[0]))
for config in args.configs_in[1:]:
# replace=False creates a merged configuration
print(kconf.load_config(config, replace=False))
if args.handwritten_input_configs:
# Check that there are no assignments to promptless symbols, which
# have no effect.
#
# This only makes sense when loading handwritten fragments and not when
# loading zephyr/.config, because zephyr/.config is configuration
# output and also assigns promptless symbols.
check_no_promptless_assign(kconf)
# Print warnings for symbols that didn't get the assigned value. Only
# do this for handwritten input too, to avoid likely unhelpful warnings
# when using an old configuration and updating Kconfig files.
check_assigned_sym_values(kconf)
check_assigned_choice_values(kconf)
# Hack: Force all symbols to be evaluated, to catch warnings generated
# during evaluation. Wait till the end to write the actual output files, so
# that we don't generate any output if there are warnings-turned-errors.
#
# Kconfiglib caches calculated symbol values internally, so this is still
# fast.
kconf.write_config(os.devnull)
if kconf.warnings:
# Put a blank line between warnings to make them easier to read
for warning in kconf.warnings:
print("\n" + warning, file=sys.stderr)
# Turn all warnings into errors, so that e.g. assignments to undefined
# Kconfig symbols become errors.
#
# A warning is generated by this script whenever a symbol gets a
# different value than the one it was assigned. Keep that one as just a
# warning for now.
err("Aborting due to Kconfig warnings")
# Write the merged configuration and the C header
print(kconf.write_config(args.config_out))
kconf.write_autoconf(args.header_out)
# Write the list of parsed Kconfig files to a file
write_kconfig_filenames(kconf, args.kconfig_list_out)
# Enable warnings for assignments to undefined symbols
kconf.enable_undef_warnings()
# (This script uses alldefconfig as the base. Other starting states could be
# set up here as well. The approach in examples/allnoconfig_simpler.py could
# provide an allnoconfig starting state for example.)
# Disable warnings generated for multiple assignments to the same symbol within
# a (set of) configuration files. Assigning a symbol multiple times might be
# done intentionally when merging configuration files.
kconf.disable_override_warnings()
kconf.disable_redun_warnings()
# Create a merged configuration by loading the fragments with replace=False
for config in sys.argv[3:]:
kconf.load_config(config, replace=False)
# Write the merged configuration
kconf.write_config(sys.argv[2])
# Print warnings for symbols whose actual value doesn't match the assigned
# value
def name_and_loc(sym):
# Helper for printing symbol names and Kconfig file location(s) in warnings
if not sym.nodes:
return sym.name + " (undefined)"
return "{} (defined at {})".format(
sym.name,
continue
if sym.orig_type in _BOOL_TRISTATE:
f.write("#define {}{}{} {}\n".format(
kconfig.config_prefix, sym.name,
"_MODULE" if val == "m" else "",
"1" if val == "y" else "0"))
elif sym.orig_type is STRING:
f.write('#define {}{} "{}"\n'.format(
kconfig.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
f.write("#define {}{} {}\n".format(kconfig.config_prefix,
sym.name, val))
config = Kconfig(sys.argv[1])
config.config_prefix = ""
try:
config.load_config('.config')
except:
print("Error: failed to open .config file, run 'make menuconfig' first.")
sys.exit(1)
write_c_header(config, "build_config.h", header="")
# Print the initial configuration tree
print_menuconfig(kconf)
while True:
try:
cmd = input('Enter a symbol/choice name, "load_config", or '
'"write_config" (or press CTRL+D to exit): ').strip()
except EOFError:
print("")
break
if cmd == "load_config":
config_filename = input(".config file to load: ")
try:
kconf.load_config(config_filename)
except IOError as e:
# Print the (spammy) error from Kconfiglib itself
print(e.message + "\n")
else:
print("Configuration loaded from " + config_filename)
print_menuconfig(kconf)
continue
if cmd == "write_config":
config_filename = input("To this file: ")
try:
kconf.write_config(config_filename)
except IOError as e:
def main():
parse_args()
print("Parsing Kconfig tree in {}".format(args.kconfig_root))
kconf = Kconfig(args.kconfig_root)
# Enable warnings for assignments to undefined symbols
kconf.enable_undef_warnings()
# This script uses alldefconfig as the base. Other starting states could be set
# up here as well. The approach in examples/allnoconfig_simpler.py could
# provide an allnoconfig starting state for example.
print("Using {} as base".format(args.conf_fragments[0]))
for config in args.conf_fragments[1:]:
print("Merging {}".format(config))
# Create a merged configuration by loading the fragments with replace=False
for config in args.conf_fragments:
kconf.load_config(config, replace=False)
# Print warnings for symbols whose actual value doesn't match the assigned
# value
def name_and_loc(sym):
# Helper for printing symbol names and Kconfig file location(s) in warnings
if not sym.nodes:
return sym.name + " (undefined)"
return "{} (defined at {})".format(
sym.name,
", ".join("{}:{}".format(node.filename, node.linenr)
for node in sym.nodes))
for sym in kconf.defined_syms:
# Was the symbol assigned to?
if sym.user_value is not None:
# Tristate values are represented as 0, 1, 2. Having them as
# "n", "m", "y" is more convenient here, so convert.
if sym.type in (BOOL, TRISTATE):
user_value = TRI_TO_STR[sym.user_value]
else:
user_value = sym.user_value
if user_value != sym.str_value:
print('warning: {} was assigned the value "{}" but got the '
'value "{}" -- check dependencies'.format(
name_and_loc(sym), user_value, sym.str_value
),
file=sys.stderr)
# Turn the warning for malformed .config lines into an error
for warning in kconf.warnings:
if "ignoring malformed line" in warning:
print("Aborting due to malformed configuration settings",
file=sys.stderr)
sys.exit(1)
# Write the merged configuration
kconf.write_config(args.dotconfig)
# Write the C header
kconf.write_autoconf(args.autoconf)
def main():
parse_args()
print("Parsing Kconfig tree in {}".format(args.kconfig_root))
kconf = Kconfig(args.kconfig_root, warn_to_stderr=False)
# Enable warnings for assignments to undefined symbols
kconf.enable_undef_warnings()
for i, config in enumerate(args.conf_fragments):
print(
("Loading {} as base" if i == 0 else "Merging {}").format(config))
# replace=False creates a merged configuration
kconf.load_config(config, replace=False)
# Print warnings for symbols whose actual value doesn't match the assigned
# value
for sym in kconf.unique_defined_syms:
# Was the symbol assigned to? Choice symbols are checked separately.
if sym.user_value is not None and not sym.choice:
verify_assigned_sym_value(sym)
# Print warnings for choices whose actual selection doesn't match the user
# selection
for choice in kconf.unique_choices:
if choice.user_selection:
verify_assigned_choice_value(choice)
# Hack: Force all symbols to be evaluated, to catch warnings generated
# during evaluation. Wait till the end to write the actual output files, so
# that we don't generate any output if there are warnings-turned-errors.
#
# Kconfiglib caches calculated symbol values internally, so this is still
# fast.
kconf.write_config(os.devnull)
# We could roll this into the loop below, but it's nice to always print all
# warnings, even if one of them turns out to be fatal
for warning in kconf.warnings:
if enabled(warning):
print("\n" + warning, file=sys.stderr)
# Turn all warnings except for explicity whitelisted ones into errors. In
# particular, this will turn assignments to undefined Kconfig variables
# into errors.
#
# A warning is generated by this script whenever a symbol gets a different
# value than the one it was assigned. Keep that one as just a warning for
# now as well.
for warning in kconf.warnings:
if fatal(warning):
sys.exit("\n" + textwrap.fill(
"Error: Aborting due to non-whitelisted Kconfig "
"warning '{}'.\nNote: If this warning doesn't point "
"to an actual problem, you can add it to the "
"whitelist at the top of {}.".format(warning, sys.argv[0]),
100) + "\n")
# Write the merged configuration and the C header
kconf.write_config(args.dotconfig)
kconf.write_autoconf(args.autoconf)
print("Parsing Kconfig tree in {}".format(sys.argv[1]))
kconf = Kconfig(sys.argv[1])
# Enable warnings for assignments to undefined symbols
kconf.enable_undef_warnings()
# (This script uses alldefconfig as the base. Other starting states could be
# set up here as well. The approach in examples/allnoconfig_simpler.py could
# provide an allnoconfig starting state for example.)
print("Using {} as base".format(sys.argv[4]))
for config in sys.argv[5:]:
print("Merging {}".format(config))
# Create a merged configuration by loading the fragments with replace=False
for config in sys.argv[4:]:
kconf.load_config(config, replace=False)
# Write the merged configuration
kconf.write_config(sys.argv[2])
# Output autoconf
kconf.write_autoconf(sys.argv[3])
# Print warnings for symbols whose actual value doesn't match the assigned
# value
def name_and_loc(sym):
# Helper for printing symbol names and Kconfig file location(s) in warnings
if not sym.nodes:
def main():
args = parse_args()
print("Parsing Kconfig tree in " + args.kconfig_root)
kconf = Kconfig(args.kconfig_root, warn_to_stderr=False)
# Warn for assignments to undefined symbols
kconf.warn_assign_undef = True
# prj.conf may override settings from the board configuration, so disable
# warnings about symbols being assigned more than once
kconf.warn_assign_override = False
kconf.warn_assign_redun = False
print(kconf.load_config(args.conf_fragments[0]))
for config in args.conf_fragments[1:]:
# replace=False creates a merged configuration
print(kconf.load_config(config, replace=False))
# Print warnings for symbols whose actual value doesn't match the assigned
# value
for sym in kconf.unique_defined_syms:
# Was the symbol assigned to? Choice symbols are checked separately.
if sym.user_value is not None and not sym.choice:
verify_assigned_sym_value(sym)
# Print warnings for choices whose actual selection doesn't match the user
# selection
for choice in kconf.unique_choices:
if choice.user_selection:
verify_assigned_choice_value(choice)
# Hack: Force all symbols to be evaluated, to catch warnings generated
# during evaluation. Wait till the end to write the actual output files, so
# that we don't generate any output if there are warnings-turned-errors.
#
# Kconfiglib caches calculated symbol values internally, so this is still
# fast.
kconf.write_config(os.devnull)
# Print warnings ourselves so that we can put a blank line between them for
# readability. We could roll this into the loop below, but it's nice to
# always print all warnings, even if one of them turns out to be fatal.
for warning in kconf.warnings:
print("\n" + warning, file=sys.stderr)
# Turn all warnings except for explicitly whitelisted ones into errors. In
# particular, this will turn assignments to undefined Kconfig variables
# into errors.
#
# A warning is generated by this script whenever a symbol gets a different
# value than the one it was assigned. Keep that one as just a warning for
# now as well.
for warning in kconf.warnings:
if fatal(warning):
sys.exit("\n" + textwrap.fill(
"Error: Aborting due to non-whitelisted Kconfig "
"warning '{}'.\nNote: If this warning doesn't point "
"to an actual problem, you can add it to the "
"whitelist at the top of {}.".format(warning, sys.argv[0]),
100) + "\n")
# Write the merged configuration and the C header
print(kconf.write_config(args.dotconfig))
kconf.write_autoconf(args.autoconf)
# Write the list of processed Kconfig sources to a file
write_kconfig_filenames(kconf.kconfig_filenames, kconf.srctree,
args.sources)
# Print the initial configuration tree
print_menuconfig(kconf)
while True:
try:
cmd = input('Enter a symbol/choice name, "load_config", or '
'"write_config" (or press CTRL+D to exit): ').strip()
except EOFError:
print("")
break
if cmd == "load_config":
config_filename = input(".config file to load: ")
try:
# Returns a message telling which file got loaded
print(kconf.load_config(config_filename))
except EnvironmentError as e:
print(e, file=sys.stderr)
print_menuconfig(kconf)
continue
if cmd == "write_config":
config_filename = input("To this file: ")
try:
# Returns a message telling which file got saved
print(kconf.write_config(config_filename))
except EnvironmentError as e:
print(e, file=sys.stderr)
continue
def main():
args = parse_args()
print("Parsing " + args.kconfig_file)
kconf = Kconfig(args.kconfig_file, warn_to_stderr=False,
suppress_traceback=True)
if args.handwritten_input_configs:
# Warn for assignments to undefined symbols, but only for handwritten
# fragments, to avoid warnings-turned-errors when using an old
# configuration file together with updated Kconfig files
kconf.warn_assign_undef = True
# prj.conf may override settings from the board configuration, so
# disable warnings about symbols being assigned more than once
kconf.warn_assign_override = False
kconf.warn_assign_redun = False
# Load configuration files
print(kconf.load_config(args.configs_in[0]))
for config in args.configs_in[1:]:
# replace=False creates a merged configuration
print(kconf.load_config(config, replace=False))
if args.handwritten_input_configs:
# Check that there are no assignments to promptless symbols, which
# have no effect.
#
# This only makes sense when loading handwritten fragments and not when
# loading zephyr/.config, because zephyr/.config is configuration
# output and also assigns promptless symbols.
check_no_promptless_assign(kconf)
# Print warnings for symbols that didn't get the assigned value. Only
# do this for handwritten input too, to avoid likely unhelpful warnings
# when using an old configuration and updating Kconfig files.
check_assigned_sym_values(kconf)
check_assigned_choice_values(kconf)
# Hack: Force all symbols to be evaluated, to catch warnings generated
# during evaluation. Wait till the end to write the actual output files, so
# that we don't generate any output if there are warnings-turned-errors.
#
# Kconfiglib caches calculated symbol values internally, so this is still
# fast.
kconf.write_config(os.devnull)
# Print warnings ourselves so that we can put a blank line between them for
# readability. We could roll this into the loop below, but it's nice to
# always print all warnings, even if one of them turns out to be fatal.
for warning in kconf.warnings:
print("\n" + warning, file=sys.stderr)
# Turn all warnings except for explicitly whitelisted ones into errors. In
# particular, this will turn assignments to undefined Kconfig variables
# into errors.
#
# A warning is generated by this script whenever a symbol gets a different
# value than the one it was assigned. Keep that one as just a warning for
# now as well.
for warning in kconf.warnings:
if fatal(warning):
err(f"""\
Aborting due to non-whitelisted Kconfig warning '{warning}'. If this warning
doesn't point to an actual problem, you can add it to the whitelist at the top
of {sys.argv[0]}.""")
# Write the merged configuration and the C header
print(kconf.write_config(args.config_out))
kconf.write_autoconf(args.header_out)
# Write the list of parsed Kconfig files to a file
write_kconfig_filenames(kconf, args.kconfig_list_out)
