diff options
| author | Ulf Magnusson <ulfalizer@gmail.com> | 2017-10-09 23:05:00 +0200 |
|---|---|---|
| committer | Ulf Magnusson <ulfalizer@gmail.com> | 2017-10-24 19:24:08 +0200 |
| commit | dd0e227216e247d2040cdd40bf7397702880cdc4 (patch) | |
| tree | 4c76ebb2e7555d28214cddecf32ffb424fa1732b | |
| parent | f64aaf971176305233f16a11911a660fa6f99561 (diff) | |
Kconfiglib 2 backup
WIP
| -rw-r--r-- | examples/allnoconfig.py | 87 | ||||
| -rw-r--r-- | examples/allnoconfig_simpler.py | 47 | ||||
| -rw-r--r-- | examples/allyesconfig.py | 133 | ||||
| -rw-r--r-- | examples/defconfig.py | 13 | ||||
| -rw-r--r-- | examples/defconfig_oldconfig.py | 12 | ||||
| -rw-r--r-- | examples/eval_expr.py | 20 | ||||
| -rw-r--r-- | examples/help_grep.py | 109 | ||||
| -rw-r--r-- | examples/print_refs.py | 13 | ||||
| -rw-r--r-- | examples/print_sym_info.py | 56 | ||||
| -rw-r--r-- | examples/print_tree.py | 80 | ||||
| -rw-r--r-- | examples/print_undefined.py | 15 | ||||
| -rw-r--r-- | kconfiglib.py | 5163 | ||||
| -rw-r--r-- | makefile.patch | 2 | ||||
| -rw-r--r-- | tests/Kchoice | 26 | ||||
| -rw-r--r-- | tests/Kdefconfig_existent | 1 | ||||
| -rw-r--r-- | tests/Keval | 1 | ||||
| -rw-r--r-- | tests/Klocation | 79 | ||||
| -rw-r--r-- | tests/Klocation_included | 43 | ||||
| -rw-r--r-- | tests/Kmisc | 2 | ||||
| -rw-r--r-- | tests/Kmodifiable | 50 | ||||
| -rw-r--r-- | tests/Kprompt | 77 | ||||
| -rw-r--r-- | tests/Krelation | 2 | ||||
| -rw-r--r-- | tests/Krepr | 61 | ||||
| -rw-r--r-- | tests/Kstr | 76 | ||||
| -rw-r--r-- | tests/Ktext | 145 | ||||
| -rw-r--r-- | tests/Kvisibility | 161 | ||||
| -rw-r--r-- | testsuite.py | 2371 |
27 files changed, 4126 insertions, 4719 deletions
diff --git a/examples/allnoconfig.py b/examples/allnoconfig.py index 9423352..edc473d 100644 --- a/examples/allnoconfig.py +++ b/examples/allnoconfig.py @@ -1,40 +1,57 @@ -# Works like allnoconfig. Automatically verified by the testsuite to generate -# identical output to 'make allnoconfig' for all ARCHes. The looping is done in -# case setting one symbol to "n" allows other symbols to be set to "n" (due to -# dependencies). +# Works like 'make allnoconfig'. Verified by the test suite to generate +# identical output to 'make allnoconfig' for all ARCHes. +# +# See allnoconfig_simpler.py for a much simpler version. This version +# demonstrates some tree walking and value processing. +# +# Usage: +# +# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/allnoconfig.py -import kconfiglib +from kconfiglib import Config, Symbol, tri_less import sys -conf = kconfiglib.Config(sys.argv[1]) - -# Do an initial pass to give allnoconfig_y symbols the user value 'y'. It might -# be possible to handle this through "successive raising" similarly to the -# "successive lowering" below too, but keep it simple. -for sym in conf: - if sym.get_type() in (kconfiglib.BOOL, kconfiglib.TRISTATE) and \ - sym.is_allnoconfig_y(): - sym.set_user_value('y') - -done = False -while not done: - done = True - - for sym in conf: - # Choices take care of themselves for allnoconfig, so we only need to - # worry about non-choice symbols - if not sym.is_choice_symbol() and not sym.is_allnoconfig_y(): - # If we can assign a value to the symbol (where "n", "m" and "y" - # are ordered from lowest to highest), then assign the lowest - # value. lower_bound() returns None for symbols whose values cannot - # (currently) be changed, as well as for non-bool/tristate symbols. - lower_bound = sym.get_lower_bound() - if lower_bound is not None and \ - kconfiglib.tri_less(lower_bound, sym.get_value()): - - sym.set_user_value(lower_bound) - # We just changed the value of some symbol. As this may affect - # other symbols, keep going. - done = False +def do_allnoconfig(node): + global no_changes + + # Walk the tree of menu nodes. You can imagine this as going down/into menu + # entries in the menuconfig interface, setting each to 'n' (or the lowest + # assignable value). + + while node is not None: + if isinstance(node.item, Symbol): + sym = node.item + + # Is the symbol a non-choice symbol that can be set to a lower + # value than its current value? + if sym.choice is None and sym.assignable and \ + tri_less(sym.assignable[0], sym.value): + + # Yup, lower it + sym.set_value(sym.assignable[0]) + no_changes = False + + # Recursively lower children + if node.list is not None: + do_allnoconfig(node.list) + + node = node.next + +conf = Config(sys.argv[1]) + +while 1: + # For tricky dependencies involving '!', setting later symbols to 'n' might + # actually raise the value of earlier symbols. To be super safe, we do + # additional passes until a pass no longer changes the value of any symbol. + # + # This isn't actually needed for any ARCH in the kernel as of 4.14. A + # single pass gives the correct result. + no_changes = True + + do_allnoconfig(conf.top_menu) + + # Did the pass change any symbols? + if no_changes: + break conf.write_config(".config") diff --git a/examples/allnoconfig_simpler.py b/examples/allnoconfig_simpler.py index f3cfe9a..e732669 100644 --- a/examples/allnoconfig_simpler.py +++ b/examples/allnoconfig_simpler.py @@ -1,28 +1,35 @@ # This is a simpler version of allnoconfig.py, corresponding to how the C -# implementation does it. Setting a user value that's not in the assignable -# range of the symbol (between get_lower_bound() and get_upper_bound(), or, -# equivalently, not in get_assignable_values()) is OK; the value will simply -# get truncated downwards or upwards as determined by the visibility and -# selects. +# implementation does it. Verified by the test suite to produce identical +# output to 'make allnoconfig' for all ARCHes. +# +# Usage: +# +# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/allnoconfig_simpler.py +# +# Implementation/performance note +# =============================== +# +# Kconfiglib immediately invalidates (flags for recalculation) all (possibly) +# dependent symbols when a value is assigned to a symbol, which slows this down +# a bit (due to tons of redundant invalidation), but makes any assignment +# pattern safe ("just works"). Config.load_config() instead invalidates all +# symbols up front, making it much faster. If you really need to eke out +# performance, look at how load_config() does things (which involves internal +# APIs that don't invalidate symbols). This has been fast enough for all cases +# I've seen so far though (around 3 seconds for this particular script on my +# Core i7 2600K, including the initial Kconfig parsing). -# This version is a bit slower compared allnoconfig.py since Kconfiglib -# invalidates all dependent symbols for each set_user_value() call. This does not -# happen for load_config(), which instead invalidates all symbols once after -# the configuration has been loaded. This is OK for load_config() since nearly -# all symbols will tend to be affected anyway. - -import kconfiglib +from kconfiglib import Config, BOOL, TRISTATE import sys -conf = kconfiglib.Config(sys.argv[1]) +conf = Config(sys.argv[1]) -# Avoid warnings printed by Kconfiglib when assigning a user value with -# set_user_value() to a symbol that has no prompt (such assignments never have -# an effect) -conf.set_print_warnings(False) +# Avoid warnings printed by Kconfiglib when assigning a value to a symbol that +# has no prompt. Such assignments never have an effect. +conf.disable_warnings() -for sym in conf: - if sym.get_type() in (kconfiglib.BOOL, kconfiglib.TRISTATE): - sym.set_user_value("y" if sym.is_allnoconfig_y() else "n") +for sym in conf.defined_syms: + if sym.type in (BOOL, TRISTATE): + sym.set_value("y" if sym.is_allnoconfig_y else "n") conf.write_config(".config") diff --git a/examples/allyesconfig.py b/examples/allyesconfig.py index 906343c..4847c05 100644 --- a/examples/allyesconfig.py +++ b/examples/allyesconfig.py @@ -1,65 +1,112 @@ -# Works like allyesconfig. This is a bit more involved than allnoconfig as we -# need to handle choices in two different modes: +# Works like 'make allyesconfig'. Verified by the test suite to generate +# identical output to 'make allyesconfig' for all ARCHES. # -# "y": One symbol is "y", the rest are "n". -# "m": Any number of symbols are "m", the rest are "n". +# This could be implemented as a straightforward tree walk just like +# allnoconfig.py (or even simpler like allnoconfig_simpler.py), but do it a bit +# differently (roundabout) just to demonstrate some other possibilities. # -# Only tristate choices can be in "m" mode. It is safe since the code for two -# conflicting options will appear as separate modules instead of simultaneously -# in the kernel. +# allyesconfig is a bit more involved than allnoconfig as we need to handle +# choices in two different modes: # -# If a choice can be in "y" mode, it will be. If it can only be in "m" mode -# (due to dependencies), then all the options will be set to "m". +# y: One symbol is "y", the rest are "n" +# m: Any number of symbols are "m", the rest are "n" # -# The looping is in case setting one symbol to "y" (or "m") allows the value of -# other symbols to be raised. +# Only tristate choices can be in "m" mode. No "m" mode choices seem to appear +# for allyesconfig on the kernel Kconfigs as of 4.14, but we still handle it. +# +# Usage: +# +# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/allyesconfig.py -import kconfiglib +from kconfiglib import Config, Choice, tri_less import sys -conf = kconfiglib.Config(sys.argv[1]) +conf = Config(sys.argv[1]) + +# Collect all the choices in the configuration. Demonstrates how the menu node +# tree can be walked iteratively by using the parent pointers. + +choices = [] +node = conf.top_menu + +while 1: + if isinstance(node.item, Choice): + choices.append(node.item) + + # Iterative tree walking by using parent pointers. + # + # Recursing on next pointers can blow the Python stack. Recursing on child + # pointers is safe (as is done in the other examples). This gives a + # template for how you can avoid recursing on both. The same logic is found + # in the C implementation. + + if node.list is not None: + # Jump to child node if available + node = node.list + + elif node.next is not None: + # Otherwise, jump to next node if available + node = node.next -# Get a list of all symbols that are not in choices -non_choice_syms = [sym for sym in conf.get_symbols() if - not sym.is_choice_symbol()] + else: + # Otherwise, look for parents with next nodes to jump to + while node.parent is not None: + node = node.parent + if node.next is not None: + node = node.next + break + else: + # No parents with next nodes, all nodes visited + break -done = False -while not done: - done = True +# Collect all symbols that are not in choices +non_choice_syms = [sym for sym in conf.defined_syms if sym.choice is None] + +while 1: + no_changes = True # Handle symbols outside of choices for sym in non_choice_syms: - upper_bound = sym.get_upper_bound() - - # See corresponding comment for allnoconfig implementation - if upper_bound is not None and \ - kconfiglib.tri_less(sym.get_value(), upper_bound): - sym.set_user_value(upper_bound) - done = False + # See allnoconfig example. [-1] gives the last (highest) assignable + # value. + if sym.assignable and tri_less(sym.value, sym.assignable[-1]): + sym.set_value(sym.assignable[-1]) + no_changes = False - # Handle symbols within choices + # Handle choices - for choice in conf.get_choices(): + for choice in choices: + # Handle a choice whose visibility allows it to be in "y" mode - # Handle choices whose visibility allow them to be in "y" mode + if choice.visibility == "y": + selection = choice.default_selection - if choice.get_visibility() == "y": - selection = choice.get_selection_from_defaults() + # Does the choice have a default selection that we haven't already + # selected? if selection is not None and \ - selection is not choice.get_user_selection(): - selection.set_user_value("y") - done = False + selection is not choice.user_value: - # Handle choices whose visibility only allow them to be in "m" mode. + # Yup, select it + selection.set_value("y") + no_changes = False + + # Handle a choice whose visibility only allows it to be in "m" mode. # This might happen if a choice depends on a symbol that can only be - # "m" for example. - - elif choice.get_visibility() == "m": - for sym in choice.get_symbols(): - if sym.get_value() != "m" and \ - sym.get_upper_bound() != "n": - sym.set_user_value("m") - done = False + # "m", for example. + + elif choice.visibility == "m": + for sym in choice.symbols: + + # Does the choice have a symbol that can be "m" that we haven't + # already set to "m"? + if sym.user_value != "m" and "m" in sym.assignable: + + # Yup, set it + sym.set_value("m") + no_changes = False + + if no_changes: + break conf.write_config(".config") diff --git a/examples/defconfig.py b/examples/defconfig.py index 3e958e2..ce2bf6e 100644 --- a/examples/defconfig.py +++ b/examples/defconfig.py @@ -1,4 +1,8 @@ # Works like entering "make menuconfig" and immediately saving and exiting +# +# Usage: +# +# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/allyesconfig.py import kconfiglib import os @@ -7,11 +11,12 @@ import sys conf = kconfiglib.Config(sys.argv[1]) if os.path.exists(".config"): + print("using existing .config") conf.load_config(".config") else: - defconfig = conf.get_defconfig_filename() - if defconfig is not None: - print("Using" + defconfig) - conf.load_config(defconfig) + if conf.defconfig_filename is not None: + print("using " + conf.defconfig_filename) + conf.load_config(conf.defconfig_filename) conf.write_config(".config") +print("configuration written to .config") diff --git a/examples/defconfig_oldconfig.py b/examples/defconfig_oldconfig.py index 9a85440..98173e7 100644 --- a/examples/defconfig_oldconfig.py +++ b/examples/defconfig_oldconfig.py @@ -7,6 +7,10 @@ # yes n | make oldconfig # # This came up in https://github.com/ulfalizer/Kconfiglib/issues/15. +# +# Usage: +# +# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/defconfig_oldconfig.py import kconfiglib import sys @@ -19,15 +23,15 @@ conf.write_config(".config") # Mirrors the first oldconfig conf.load_config(".config") -conf["ETHERNET"].set_user_value('n') +conf.syms["ETHERNET"].set_value('n') conf.write_config(".config") # Mirrors the second oldconfig conf.load_config(".config") -conf["ETHERNET"].set_user_value('y') +conf.syms["ETHERNET"].set_value('y') for s in conf: - if s.get_user_value() is None and 'n' in s.get_assignable_values(): - s.set_user_value('n') + if s.user_value is None and 'n' in s.assignable: + s.set_value('n') # Write the final configuration conf.write_config(".config") diff --git a/examples/eval_expr.py b/examples/eval_expr.py index edb33e6..a907f35 100644 --- a/examples/eval_expr.py +++ b/examples/eval_expr.py @@ -1,8 +1,22 @@ -# Evaluates an expression in the context of a configuration. (Here we could -# load a .config as well.) +# Evaluates an expression (e.g. "X86_64 || (X86_32 && X86_LOCAL_APIC)") in the +# context of a configuration. Note that this always yields a tristate value (n, +# m, or y). +# +# Usage: +# +# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/eval_expr.py SCRIPT_ARG=<expr> import kconfiglib import sys +if len(sys.argv) < 3: + print('Pass symbol name (without "CONFIG_" prefix) with SCRIPT_ARG=NAME') + sys.exit(1) + conf = kconfiglib.Config(sys.argv[1]) -print(conf.eval("(TRACE_IRQFLAGS_SUPPORT || PPC32) && STACKTRACE_SUPPORT")) + +# Enable modules so that 'm' doesn't get demoted to 'n' +conf.syms["MODULES"].set_value("y") + +print("the expression '{}' evaluates to {}" + .format(sys.argv[2], conf.eval_string(sys.argv[2]))) diff --git a/examples/help_grep.py b/examples/help_grep.py index 61ac936..fed1731 100644 --- a/examples/help_grep.py +++ b/examples/help_grep.py @@ -1,49 +1,72 @@ -# Does a case-insensitive search for a string in the help texts for symbols and -# choices and the titles of menus and comments. Prints the matching items -# together with their locations and the matching text. Used like +# Does a case-insensitive search for a regular expression in the help texts of +# symbols and choices and the prompts of menus and comments. Prints the +# matching items together with their locations and the matching text. # -# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/help_grep.py SCRIPT_ARG=<search text> +# Usage: +# +# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/help_grep.py SCRIPT_ARG=<regex> +# +# Shortened example output for SCRIPT_ARG=general: +# +# menu "General setup" +# location: init/Kconfig:39 +# +# config SYSVIPC +# bool +# prompt "System V IPC" +# help +# ... +# exchange information. It is generally considered to be a good thing, +# ... +# +# location: init/Kconfig:233 +# +# config BSD_PROCESS_ACCT +# bool +# prompt "BSD Process Accounting" if MULTIUSER +# help +# ... +# information. This is generally a good idea, so say Y. +# +# location: init/Kconfig:403 +# +# ... + -import kconfiglib +from kconfiglib import Config, Symbol, Choice, MENU, COMMENT +import re import sys if len(sys.argv) < 3: - print('Pass search string with SCRIPT_ARG="search string"') + print('Pass the regex with SCRIPT_ARG=regex') sys.exit(1) -search_string = sys.argv[2].lower() - -conf = kconfiglib.Config(sys.argv[1]) - -for item in conf.get_symbols() + \ - conf.get_choices() + conf.get_menus() + conf.get_comments(): - if item.is_symbol() or item.is_choice(): - text = item.get_help() - elif item.is_menu(): - text = item.get_title() - else: - # Comment - text = item.get_text() - - # Case-insensitive search - if text is not None and search_string in text.lower(): - if item.is_symbol() or item.is_choice(): - # Indent lines in help text. (There might be a nicer way. :) - text = "\n".join([" " + s for s in text.splitlines()]) - - # Don't worry about symbols/choices defined in multiple locations to - # keep things simple - fname, linenr = item.get_def_locations()[0] - if item.is_symbol(): - print("config {0} at {1}:{2}:\n{3}" - .format(item.get_name(), fname, linenr, text)) - elif item.is_choice(): - print("choice at {0}:{1}:\n{2}".format(fname, linenr, text)) - - else: - # Menu or comment - fname, linenr = item.get_location() - if item.is_menu(): - print('menu "{0}" at {1}:{2}'.format(text, fname, linenr)) - else: - # Comment - print('comment "{0}" at {1}:{2}'.format(text, fname, linenr)) + +search = re.compile(sys.argv[2], re.IGNORECASE).search + +def search_tree(node): + while node is not None: + match = False + + if isinstance(node.item, (Symbol, Choice)) and \ + node.help is not None and search(node.help): + print(node.item) + match = True + + elif node.item == MENU and search(node.prompt[0]): + print('menu "{}"'.format(node.prompt[0])) + match = True + + elif node.item == COMMENT and search(node.prompt[0]): + print('comment "{}"'.format(node.prompt[0])) + match = True + + if match: + print("location: {}:{}\n".format(node.filename, node.linenr)) + + if node.list is not None: + search_tree(node.list) + + node = node.next + +conf = Config(sys.argv[1]) +search_tree(conf.top_menu) diff --git a/examples/print_refs.py b/examples/print_refs.py deleted file mode 100644 index ea62223..0000000 --- a/examples/print_refs.py +++ /dev/null @@ -1,13 +0,0 @@ -# Prints the names of all symbols that reference a particular symbol. (There's -# also a method get_selected_symbols() for determining just selection -# relations.) - -import kconfiglib -import sys - -conf = kconfiglib.Config(sys.argv[1]) - -x86 = conf["X86"] -for sym in conf: - if x86 in sym.get_referenced_symbols(): - print(sym.get_name()) diff --git a/examples/print_sym_info.py b/examples/print_sym_info.py index c913358..2c1b0f0 100644 --- a/examples/print_sym_info.py +++ b/examples/print_sym_info.py @@ -1,18 +1,52 @@ -# Loads a Kconfig and a .config and prints information about a symbol. +# Loads a Kconfig and a .config and prints a symbol. +# +# Usage: +# +# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/print_sym_info.py SCRIPT_ARG=<name> +# +# Example output for SCRIPT_ARG=modules: +# +# config MODULES +# bool +# prompt "Enable loadable module support" +# option modules +# help +# Kernel modules are small pieces of compiled code which can +# be inserted in the running kernel, rather than being +# permanently built into the kernel. You use the "modprobe" +# tool to add (and sometimes remove) them. If you say Y here, +# many parts of the kernel can be built as modules (by +# answering M instead of Y where indicated): this is most +# useful for infrequently used options which are not required +# for booting. For more information, see the man pages for +# modprobe, lsmod, modinfo, insmod and rmmod. +# +# If you say Y here, you will need to run "make +# modules_install" to put the modules under /lib/modules/ +# where modprobe can find them (you may need to be root to do +# this). +# +# If unsure, say Y. +# +# value = n +# visibility = y +# currently assignable values: n, y +# defined at init/Kconfig:1678 import kconfiglib import sys -# Create a Config object representing a Kconfig configuration. (Any number of -# these can be created -- the library has no global state.) +if len(sys.argv) < 3: + print('Pass symbol name (without "CONFIG_" prefix) with SCRIPT_ARG=<name>') + sys.exit(1) + conf = kconfiglib.Config(sys.argv[1]) +sym = conf.syms[sys.argv[2]] -# Load values from a .config file. 'srctree' is an environment variable set by -# the Linux makefiles to the top-level directory of the kernel tree. It needs -# to be used here for the script to work with alternative build directories -# (specified e.g. with O=). -conf.load_config("$srctree/arch/x86/configs/i386_defconfig") +print(sym) +print("value = " + sym.value) +print("visibility = " + sym.visibility) +print("currently assignable values: " + ", ".join(sym.assignable)) -# Print some information about a symbol. (The Config class implements -# __getitem__() to provide a handy syntax for getting symbols.) -print(conf["SERIAL_UARTLITE_CONSOLE"]) +for node in sym.nodes: + print("defined at {}:{}".format(node.filename, node.linenr)) diff --git a/examples/print_tree.py b/examples/print_tree.py index 1405ed5..da795c9 100644 --- a/examples/print_tree.py +++ b/examples/print_tree.py @@ -1,23 +1,67 @@ -# Prints a tree of all items in the configuration +# Prints the menu tree of the configuration. Dependencies between symbols can +# sometimes implicitly alter the menu structure (see kconfig-language.txt), and +# that's implemented too. +# +# Usage: +# +# $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/print_tree.py +# +# Example output: +# +# ... +# config HAVE_KERNEL_LZO +# config HAVE_KERNEL_LZ4 +# choice +# config KERNEL_GZIP +# config KERNEL_BZIP2 +# config KERNEL_LZMA +# config KERNEL_XZ +# config KERNEL_LZO +# config KERNEL_LZ4 +# config DEFAULT_HOSTNAME +# config SWAP +# config SYSVIPC +# config SYSVIPC_SYSCTL +# config POSIX_MQUEUE +# config POSIX_MQUEUE_SYSCTL +# config CROSS_MEMORY_ATTACH +# config FHANDLE +# config USELIB +# config AUDIT +# config HAVE_ARCH_AUDITSYSCALL +# config AUDITSYSCALL +# config AUDIT_WATCH +# config AUDIT_TREE +# menu "IRQ subsystem" +# config MAY_HAVE_SPARSE_IRQ +# config GENERIC_IRQ_LEGACY +# config GENERIC_IRQ_PROBE +# ... -import kconfiglib +from kconfiglib import Config, Symbol, Choice, MENU, COMMENT import sys -def print_with_indent(s, indent): +def indent_print(s, indent): print((" " * indent) + s) -def print_items(items, indent): - for item in items: - if item.is_symbol(): - print_with_indent("config {0}".format(item.get_name()), indent) - elif item.is_menu(): - print_with_indent('menu "{0}"'.format(item.get_title()), indent) - print_items(item.get_items(), indent + 2) - elif item.is_choice(): - print_with_indent('choice', indent) - print_items(item.get_items(), indent + 2) - elif item.is_comment(): - print_with_indent('comment "{0}"'.format(item.get_text()), indent) - -conf = kconfiglib.Config(sys.argv[1]) -print_items(conf.get_top_level_items(), 0) +def print_items(node, indent): + while node is not None: + if isinstance(node.item, Symbol): + indent_print("config " + node.item.name, indent) + + elif isinstance(node.item, Choice): + indent_print("choice", indent) + + elif node.item == MENU: + indent_print('menu "{0}"'.format(node.prompt[0]), indent) + + elif node.item == COMMENT: + indent_print('comment "{0}"'.format(node.prompt[0]), indent) + + if node.list is not None: + print_items(node.list, indent + 2) + + node = node.next + +conf = Config(sys.argv[1]) +print_items(conf.top_menu, 0) diff --git a/examples/print_undefined.py b/examples/print_undefined.py deleted file mode 100644 index fb8120b..0000000 --- a/examples/print_undefined.py +++ /dev/null @@ -1,15 +0,0 @@ -# Prints the names of all symbols that are referenced but never defined in the -# current configuration together with the locations where they are referenced. -# Integers being included in the list is not a bug, as these need to be treated -# as symbols per the design of Kconfig. - -import kconfiglib -import sys - -conf = kconfiglib.Config(sys.argv[1]) - -for sym in conf.get_symbols(): - if not sym.is_defined(): - print(sym.get_name()) - for (filename, linenr) in sym.get_ref_locations(): - print(" {0}:{1}".format(filename, linenr)) diff --git a/kconfiglib.py b/kconfiglib.py index 186c931..e4d0b58 100644 --- a/kconfiglib.py +++ b/kconfiglib.py @@ -1,71 +1,73 @@ -# This is Kconfiglib, a Python library for scripting, debugging, and extracting -# information from Kconfig-based configuration systems. To view the -# documentation, run -# -# $ pydoc kconfiglib -# -# or, if you prefer HTML, -# -# $ pydoc -w kconfiglib -# -# The examples/ subdirectory contains examples, to be run with e.g. -# -# $ make scriptconfig SCRIPT=Kconfiglib/examples/print_tree.py -# -# Look in testsuite.py for the test suite. - """ -Kconfiglib is a Python library for scripting and extracting information from -Kconfig-based configuration systems. Features include the following: +Kconfiglib is a Python 2/3 library for scripting and extracting information +from Kconfig-based configuration systems. Features include the following: + + - Programmatic getting and setting of symbol values + + - Reading/writing of .config files + + - Expression inspection and evaluation. All expressions are exposed and use a + simple format that can be processed manually if needed. + + - Menu tree inspection. The underlying menu tree is exposed, including + submenus created implicitly by symbols depending on preceding symbols. This + can be used e.g. to implement menuconfig-like functionality. + + - Highly compatible with the standard Kconfig C tools: The test suite compares + outputs between Kconfiglib and the C tools on real-world kernel Kconfig and + defconfig files for a large number of cases (by diffing generated .configs). + + - Pretty speedy by pure Python standards: Parses the x86 Kconfigs in about a + second on a Core i7 2600K (with a warm file cache). For long-running jobs, + PyPy gives a nice speedup. + +For the Linux kernel, a handy interface is provided by the +scripts/kconfig/Makefile patch. For experimentation, you can use the +iscriptconfig target, which gives an interactive Python prompt where the +configuration for ARCH has been loaded: - - Symbol values and properties can be looked up and values assigned - programmatically. - - .config files can be read and written. - - Expressions can be evaluated in the context of a Kconfig configuration. - - Relations between symbols can be quickly determined, such as finding all - symbols that reference a particular symbol. - - Highly compatible with the scripts/kconfig/*conf utilities. The test suite - automatically compares outputs between Kconfiglib and the C implementation - for a large number of cases. + $ make [ARCH=<arch>] iscriptconfig -For the Linux kernel, scripts are run using +To run a script, use the scriptconfig target: - $ make scriptconfig [ARCH=<arch>] SCRIPT=<path to script> [SCRIPT_ARG=<arg>] + $ make [ARCH=<arch>] scriptconfig SCRIPT=<path to script> [SCRIPT_ARG=<arg>] -Using the 'scriptconfig' target ensures that required environment variables -(SRCARCH, ARCH, srctree, KERNELVERSION, etc.) are set up correctly. +See the examples/ subdirectory for example scripts. -Scripts receive the name of the Kconfig file to load in sys.argv[1]. As of -Linux 4.1.0-rc5, this is always "Kconfig" from the kernel top-level directory. -If an argument is provided with SCRIPT_ARG, it appears as sys.argv[2]. -To get an interactive Python prompt with Kconfiglib preloaded and a Config -object 'c' created, run +The Makefile patch is used to pick up the ARCH, SRCARCH, and KERNELVERSION +environment variables (and any future environment variables that might get +used). If you want to run Kconfiglib without the Makefile patch, the following +will probably work in practice (it's what the test suite does in 'speedy' mode, +except it tests all ARCHes): - $ make iscriptconfig [ARCH=<arch>] + $ ARCH=x86 SRCARCH=x86 KERNELVERSION=`make kernelversion` python script.py -Kconfiglib supports both Python 2 and Python 3. For (i)scriptconfig, the Python -interpreter to use can be passed in PYTHONCMD, which defaults to 'python'. PyPy -works well too, and might give a nice speedup for long-running jobs. +ARCH and SRCARCH (the arch/ subdirectory) might differ in some cases. Search +for "Additional ARCH settings for" in the top-level Makefile to see the +possible variations. The value of KERNELVERSION doesn't seem to matter as of +Linux 4.14. -The examples/ directory contains short example scripts, which can be run with -e.g. +Kconfiglib will warn if you forget to set some environment variable that's +referenced in the configuration (via 'option env="ENV_VAR"'). - $ make scriptconfig SCRIPT=Kconfiglib/examples/print_tree.py -or +When using scriptconfig, scripts receive the name of the Kconfig file to load +in sys.argv[1]. As far as I can tell, this is always "Kconfig" from the kernel +top-level directory as of Linux 4.14. If an argument is provided with +SCRIPT_ARG, it appears as sys.argv[2]. - $ make scriptconfig SCRIPT=Kconfiglib/examples/help_grep.py SCRIPT_ARG=kernel -testsuite.py contains the test suite. See the top of the script for how to run -it. +Kconfiglib supports both Python 2 and Python 3 (and PyPy). For (i)scriptconfig, +the Python interpreter to use can be passed in PYTHONCMD, which defaults to +"python". -Credits: Written by Ulf "Ulfalizer" Magnusson -Send bug reports, suggestions and other feedback to ulfalizer a.t Google's -email service. Don't wrestle with internal APIs. Tell me what you need and I -might add it in a safe way as a client API instead.""" +Send bug reports, suggestions, and questions to ulfalizer a.t Google's email +service (or open a ticket on the GitHub page). +""" +import errno import os import platform import re @@ -87,801 +89,925 @@ import sys # class Config(object): - - """Represents a Kconfig configuration, e.g. for i386 or ARM. This is the - set of symbols and other items appearing in the configuration together with - their values. Creating any number of Config objects -- including for - different architectures -- is safe; Kconfiglib has no global state.""" + """ + Represents a Kconfig configuration, e.g. for x86 or ARM. This is the set of + symbols, choices, and menu nodes appearing in the configuration. Creating + any number of Config objects (including for different architectures) is + safe. Kconfiglib doesn't keep any global state. + + The following attributes are available on Config instances. They should be + viewed as read-only, and some are implemented through @property magic. + Modifying symbols is fine, but not the 'syms' dictionary itself. + + syms: + A dictionary with all symbols in the configuration. The key is the name + of the symbol, so that e.g. conf.syms["MODULES"] returns the MODULES + symbol. Symbols that are referenced in expressions but never defined are + included as well. + + defined_syms: + A list of all defined symbols, in the same order as they appear in the + Kconfig files. Provided as a convenience (and also used internally). The + defined symbols are those whose 'nodes' attribute is non-empty. + + named_choices: + A dictionary like 'syms' for named choices (choice FOO). This is mostly + for completeness. I've never seen named choices being used. + + top_menu: + The menu node (see the MenuNode class) of the top-level menu. Acts as the + root of the menu tree. + + mainmenu_text: + The prompt (title) of the top_menu menu, with Kconfig variable references + ("$FOO") expanded. Defaults to "Linux Kernel Configuration" (like in the + C tools). Can be changed with the 'mainmenu' statement (see + kconfig-language.txt). + + defconfig_filename: + The filename given by the 'option defconfig_list' symbol. This is the + first existing file with a satisfied condition among the 'default' + properties of the symbol. If a file is not found at the given path, it is + also looked up relative to $srctree if set ($srctree/foo/defconfig is + looked up if foo/defconfig is not found). + + Has the value None if either no defconfig_list symbol exists, or if it + has no 'default' with a satisfied dependency that points to an existing + file. + + References to Kconfig symbols ("$FOO") are expanded in 'default' + properties. + + Setting 'option defconfig_list' on multiple symbols ignores symbols past + the first one. + + Do print(c.syms["DEFCONFIG_LIST"]) on a kernel configuration to see an + example of a defconfig_list symbol. + + Something to look out for is that scripts/kconfig/Makefile might use the + --defconfig=<defconfig> option when calling the C tools of e.g. 'make + defconfig'. This option overrides the 'option defconfig_list' symbol, + meaning defconfig_filename might not match what 'make defconfig' would + use. + + srctree: + The value of the $srctree environment variable when the configuration was + loaded, or None if $srctree wasn't set. Kconfig and .config files are + looked up relative to $srctree if they are not found in the base path + (unless absolute paths are specified). This is to support out-of-tree + builds. The C tools use this variable in the same way. + + Changing $srctree after loading the configuration has no effect. Only the + value when the configuration is loaded matters. This avoids surprises if + multiple configurations are loaded with different values for $srctree. + + config_prefix: + The value of the $CONFIG_ environment variable when the configuration was + loaded. This is the prefix used (and expected) in .config files. Defaults + to "CONFIG_". Used in the same way in the C tools. + + Like for srctree, only the value of $CONFIG_ when the configuration is + loaded matters. + """ + + __slots__ = ( + "_choices", + "_print_undef_assign", + "_print_warnings", + "_set_re", + "_unset_re", + "config_prefix", + "defconfig_list", + "defined_syms", + "modules", + "named_choices", + "srctree", + "syms", + "top_menu", + ) # # Public interface # - def __init__(self, filename="Kconfig", base_dir=None, print_warnings=True, - print_undef_assign=False): - """Creates a new Config object, representing a Kconfig configuration. - Raises Kconfig_Syntax_Error on syntax errors. - - filename (default: "Kconfig"): The base Kconfig file of the - configuration. For the Linux kernel, you'll probably want "Kconfig" - from the top-level directory, as environment variables will make - sure the right Kconfig is included from there - (arch/<architecture>/Kconfig). If you are using Kconfiglib via 'make - scriptconfig', the filename of the base base Kconfig file will be in - sys.argv[1]. - - base_dir (default: None): The base directory relative to which 'source' - statements within Kconfig files will work. For the Linux kernel this - should be the top-level directory of the kernel tree. $-references - to existing environment variables will be expanded. - - If None (the default), the environment variable 'srctree' will be - used if set, and the current directory otherwise. 'srctree' is set - by the Linux makefiles to the top-level kernel directory. A default - of "." would not work with an alternative build directory. - - print_warnings (default: True): Set to True if warnings related to this - configuration should be printed to stderr. This can be changed later - with Config.set_print_warnings(). It is provided as a constructor - argument since warnings might be generated during parsing. - - print_undef_assign (default: False): Set to True if informational - messages related to assignments to undefined symbols should be - printed to stderr for this configuration. Can be changed later with - Config.set_print_undef_assign().""" - - # The set of all symbols, indexed by name (a string) - self._syms = {} - - # The set of all defined symbols in the configuration in the order they - # appear in the Kconfig files. This excludes the special symbols n, m, - # and y as well as symbols that are referenced but never defined. - self._defined_syms = [] - - # The set of all named choices (yes, choices can have names), indexed - # by name (a string) - self._named_choices = {} - - # Lists containing all choices, menus, and comments in the - # configuration + def __init__(self, filename="Kconfig", warn=True): + """ + Creates a new Config object by parsing Kconfig files. Raises + KconfigSyntaxError on syntax errors. Note that Kconfig files are not + the same as .config files (which store configuration symbol values). + + filename (default: "Kconfig"): + The base Kconfig file. For the Linux kernel, you'll want "Kconfig" + from the top-level directory, as environment variables will make sure + the right Kconfig is included from there + (arch/<architecture>/Kconfig). If you are using Kconfiglib via 'make + scriptconfig', the filename of the base base Kconfig file will be in + sys.argv[1] (always "Kconfig" in practice). + + The $srctree environment variable is used if set (see the class + documentation). + + warn (default: True): + True if warnings related to this configuration should be printed to + stderr. This can be changed later with + Config.enable/disable_warnings(). It is provided as a constructor + argument since warnings might be generated during parsing. + """ + + self.syms = {} + self.defined_syms = [] + self.named_choices = {} + + # Used for quickly invalidating all choices self._choices = [] - self._menus = [] - self._comments = [] - - def register_special_symbol(type_, name, val): - sym = Symbol() - sym._is_special = True - sym._is_defined = True - sym._config = self - sym._name = name - sym._type = type_ - sym._cached_val = val - self._syms[name] = sym - return sym - - # The special symbols n, m and y, used as shorthand for "n", "m" and - # "y" - self._n = register_special_symbol(TRISTATE, "n", "n") - self._m = register_special_symbol(TRISTATE, "m", "m") - self._y = register_special_symbol(TRISTATE, "y", "y") - # DEFCONFIG_LIST uses this - register_special_symbol(STRING, "UNAME_RELEASE", platform.uname()[2]) + + # Predefined symbol. DEFCONFIG_LIST has been seen using this. + uname_sym = Symbol() + uname_sym._type = STRING + uname_sym.name = "UNAME_RELEASE" + uname_sym.config = self + uname_sym.defaults.append((platform.uname()[2], None)) + # env_var doubles as the SYMBOL_AUTO flag from the C implementation, so + # just set it to something. The naming breaks a bit here, but it's + # pretty obscure. + uname_sym.env_var = "<uname release>" + self.syms["UNAME_RELEASE"] = uname_sym # The symbol with "option defconfig_list" set, containing a list of # default .config files - self._defconfig_sym = None + self.defconfig_list = None - # See Symbol.get_(src)arch() - self._arch = os.environ.get("ARCH") - self._srcarch = os.environ.get("SRCARCH") - - # If you set CONFIG_ in the environment, Kconfig will prefix all - # symbols with its value when saving the configuration, instead of - # using the default, "CONFIG_". - self._config_prefix = os.environ.get("CONFIG_") - if self._config_prefix is None: - self._config_prefix = "CONFIG_" + self.config_prefix = os.environ.get("CONFIG_") + if self.config_prefix is None: + self.config_prefix = "CONFIG_" # Regular expressions for parsing .config files self._set_re = re.compile(r"{}(\w+)=(.*)" - .format(self._config_prefix)) + .format(self.config_prefix)) self._unset_re = re.compile(r"# {}(\w+) is not set" - .format(self._config_prefix)) + .format(self.config_prefix)) - self._kconfig_filename = filename + self.srctree = os.environ.get("srctree") - # See Config.__init__(). We need this for get_defconfig_filename(). - self._srctree = os.environ.get("srctree") + self._print_warnings = warn + self._print_undef_assign = False - if base_dir is None: - self._base_dir = "." if self._srctree is None else self._srctree - else: - self._base_dir = os.path.expandvars(base_dir) + self.top_menu = MenuNode() + self.top_menu.config = self + self.top_menu.item = MENU + self.top_menu.visibility = None + self.top_menu.prompt = ("Linux Kernel Configuration", None) + self.top_menu.parent = None + self.top_menu.dep = None + self.top_menu.filename = filename + self.top_menu.linenr = 1 - # The 'mainmenu' text - self._mainmenu_text = None + # We hardcode MODULES for backwards compatibility. Proper support via + # 'option modules' wouldn't be that tricky to add with backwards + # compatibility either though. + self.modules = self._lookup_sym("MODULES") - # The filename of the most recently loaded .config file - self._config_filename = None - # The textual header of the most recently loaded .config, uncommented - self._config_header = None + # Parse the Kconfig files + self._parse_block(_FileFeed(self._open(filename), filename), + None, self.top_menu, None, None, self.top_menu) - self._print_warnings = print_warnings - self._print_undef_assign = print_undef_assign + self.top_menu.list = self.top_menu.next + self.top_menu.next = None - # When parsing properties, we stop on the first (non-empty) - # non-property line. _end_line and _end_line_tokens hold that line and - # its tokens so that we don't have to re-tokenize the line later. This - # isn't just an optimization: We record references to symbols during - # tokenization, so tokenizing twice would cause double registration. - # - # self._end_line doubles as a flag where None means we don't have a - # cached tokenized line. - self._end_line = None - # self.end_line_tokens is set later during parsing - - # Parse the Kconfig files - self._top_block = [] - self._parse_file(filename, None, None, None, self._top_block) + _finalize_tree(self.top_menu) # Build Symbol._direct_dependents for all symbols self._build_dep() - def get_arch(self): - """Returns the value the environment variable ARCH had at the time the - Config instance was created, or None if ARCH was not set. For the - kernel, this corresponds to the architecture being built for, with - values such as "i386" or "mips".""" - return self._arch - - def get_srcarch(self): - """Returns the value the environment variable SRCARCH had at the time - the Config instance was created, or None if SRCARCH was not set. For - the kernel, this corresponds to the particular arch/ subdirectory - containing architecture-specific code.""" - return self._srcarch - - def get_srctree(self): - """Returns the value the environment variable 'srctree' had at the time - the Config instance was created, or None if 'srctree' was not defined. - This variable points to the source directory and is used when building - in a separate directory.""" - return self._srctree - - def get_base_dir(self): - """Returns the base directory relative to which 'source' statements - will work, passed as an argument to Config.__init__().""" - return self._base_dir - - def get_kconfig_filename(self): - """Returns the name of the (base) kconfig file this configuration was - loaded from.""" - return self._kconfig_filename - - def get_config_filename(self): - """Returns the filename of the most recently loaded configuration file, - or None if no configuration has been loaded.""" - return self._config_filename - - def get_config_header(self): - """Returns the (uncommented) textual header of the .config file most - recently loaded with load_config(). Returns None if no .config file has - been loaded or if the most recently loaded .config file has no header. - - The header consists of all lines up to but not including the first line - that either (1) does not begin with "#", or (2) matches - "# CONFIG_FOO is not set".""" - return self._config_header - - def get_mainmenu_text(self): - """Returns the text of the 'mainmenu' statement (with $-references to - symbols replaced by symbol values), or None if the configuration has no - 'mainmenu' statement.""" - return None if self._mainmenu_text is None else \ - self._expand_sym_refs(self._mainmenu_text) - - def get_defconfig_filename(self): - """Returns the name of the defconfig file, which is the first existing - file in the list given in a symbol having 'option defconfig_list' set. - $-references to symbols will be expanded ("$FOO bar" -> "foo bar" if - FOO has the value "foo"). Returns None in case of no defconfig file. - Setting 'option defconfig_list' on multiple symbols ignores the symbols - past the first one (and prints a warning). - - If the environment variable 'srctree' was set when the Config was - created, each defconfig specified with a relative path will be - searched for in $srcdir if it is not found at the specified path (i.e., - if foo/defconfig is not found, $srctree/foo/defconfig will be looked - up). - - WARNING: A wart here is that scripts/kconfig/Makefile sometimes uses - the --defconfig=<defconfig> option when calling the C implementation of - e.g. 'make defconfig'. This option overrides the 'option - defconfig_list' symbol, meaning the result from - get_defconfig_filename() might not match what 'make defconfig' would - use. That probably ought to be worked around somehow, so that this - function always gives the "expected" result.""" - if self._defconfig_sym is None: + @property + def mainmenu_text(self): + """ + See the class documentation. + """ + return self._expand_sym_refs(self.top_menu.prompt[0]) + + @property + def defconfig_filename(self): + """ + See the class documentation. + """ + if self.defconfig_list is None: return None - for filename, cond_expr in self._defconfig_sym._def_exprs: - if self._eval_expr(cond_expr) != "n": + for filename, cond_expr in self.defconfig_list.defaults: + if eval_expr(cond_expr) != "n": filename = self._expand_sym_refs(filename) - if os.access(filename, os.R_OK): - return filename - # defconfig not found. If the path is a relative path and - # $srctree is set, we also look in $srctree. - if not os.path.isabs(filename) and self._srctree is not None: - filename = os.path.join(self._srctree, filename) - if os.access(filename, os.R_OK): - return filename + try: + with self._open(filename) as f: + return f.name + except IOError: + continue return None - def get_symbol(self, name): - """Returns the symbol with name 'name', or None if no such symbol - appears in the configuration. An alternative shorthand is conf[name], - where conf is a Config instance, though that will instead raise - KeyError if the symbol does not exist.""" - return self._syms.get(name) - - def __getitem__(self, name): - """Returns the symbol with name 'name'. Raises KeyError if the symbol - does not appear in the configuration.""" - return self._syms[name] - - def get_symbols(self, all_symbols=True): - """Returns a list of symbols from the configuration. An alternative for - iterating over all defined symbols (in the order of definition) is - - for sym in config: - ... - - which relies on Config implementing __iter__() and is equivalent to - - for sym in config.get_symbols(False): - ... - - all_symbols (default: True): If True, all symbols -- including special - and undefined symbols -- will be included in the result, in an - undefined order. If False, only symbols actually defined and not - merely referred to in the configuration will be included in the - result, and will appear in the order that they are defined within - the Kconfig configuration files.""" - return list(self._syms.values()) if all_symbols else \ - self._defined_syms - - def __iter__(self): - """Convenience function for iterating over the set of all defined - symbols in the configuration, used like - - for sym in conf: - ... - - The iteration happens in the order of definition within the Kconfig - configuration files. Symbols only referred to but not defined will not - be included, nor will the special symbols n, m, and y. If you want to - include such symbols as well, see config.get_symbols().""" - return iter(self._defined_syms) - - def get_choices(self): - """Returns a list containing all choice statements in the - configuration, in the order they appear in the Kconfig files.""" - return self._choices - - def get_menus(self): - """Returns a list containing all menus in the configuration, in the - order they appear in the Kconfig files.""" - return self._menus - - def get_comments(self): - """Returns a list containing all comments in the configuration, in the - order they appear in the Kconfig files.""" - return self._comments - - def get_top_level_items(self): - """Returns a list containing the items (symbols, menus, choices, and - comments) at the top level of the configuration -- that is, all items - that do not appear within a menu or choice. The items appear in the - same order as within the configuration.""" - return self._top_block - def load_config(self, filename, replace=True): - """Loads symbol values from a file in the familiar .config format. - Equivalent to calling Symbol.set_user_value() to set each of the - values. + """ + Loads symbol values from a file in the .config format. Equivalent to + calling Symbol.set_value() to set each of the values. "# CONFIG_FOO is not set" within a .config file is treated specially - and sets the user value of FOO to 'n'. The C implementation works the - same way. - - filename: The .config file to load. $-references to existing - environment variables will be expanded. For scripts to work even when - an alternative build directory is used with the Linux kernel, you - need to refer to the top-level kernel directory with "$srctree". - - replace (default: True): True if the configuration should replace the - old configuration; False if it should add to it.""" - - # Put this first so that a missing file doesn't screw up our state - filename = os.path.expandvars(filename) - line_feeder = _FileFeed(filename) + and sets the user value of FOO to 'n'. The C tools work the same way. - self._config_filename = filename - - # - # Read header - # + filename: + The .config file to load. The $srctree variable is used if set (see + the class documentation). - if not self._is_header_line(line_feeder.peek_next()): - self._config_header = None - else: - # Kinda inefficient, but this is an unlikely hotspot - self._config_header = "" - while self._is_header_line(line_feeder.peek_next()): - self._config_header += line_feeder.get_next()[1:] - # Makes c.write_config(".config", c.get_config_header()) preserve - # the header exactly. We also handle weird cases like a .config - # file with just "# foo" and no trailing newline in it (though we - # would never generate that ourselves), hence the slight - # awkwardness. - if self._config_header.endswith("\n"): - self._config_header = self._config_header[:-1] - - # - # Read assignments. Hotspot for some workloads. - # - - if replace: - # This invalidates all symbols as a side effect - self.unset_user_values() - else: - self._invalidate_all() - - # Small optimization - set_re_match = self._set_re.match - unset_re_match = self._unset_re.match - - while 1: - line = line_feeder.get_next() - if line is None: - return - - line = line.rstrip() + replace (default: True): True if all existing user values should + be cleared before loading the .config. + """ - set_match = set_re_match(line) - if set_match: - name, val = set_match.groups() - if name not in self._syms: - self._warn_undef_assign_load( - name, val, line_feeder.filename, line_feeder.linenr) - continue + with self._open(filename) as f: + if replace: + # Invalidates all symbols as a side effect + self.unset_values() + else: + self._invalidate_all() + + # Small optimizations + set_re_match = self._set_re.match + unset_re_match = self._unset_re.match + syms = self.syms + + for linenr, line in enumerate(f, 1): + # The C tools ignore trailing whitespace + line = line.rstrip() + + set_match = set_re_match(line) + if set_match: + name, val = set_match.groups() + if name not in syms: + self._warn_undef_assign_load(name, val, filename, + linenr) + continue - sym = self._syms[name] + sym = syms[name] + + if sym._type == STRING and val.startswith('"'): + if len(val) < 2 or val[-1] != '"': + self._warn("malformed string literal", filename, + linenr) + continue + # Strip quotes and remove escapings. The unescaping + # procedure should be safe since " can only appear as + # \" inside the string. + val = val[1:-1].replace('\\"', '"') \ + .replace("\\\\", "\\") + + if sym.choice is not None: + mode = sym.choice.user_value + if mode is not None and mode != val: + self._warn("assignment to {} changes mode of " + 'containing choice from "{}" to "{}".' + .format(name, val, mode), + filename, linenr) - if sym._type == STRING and val.startswith('"'): - if len(val) < 2 or val[-1] != '"': - self._warn("malformed string literal", - line_feeder.filename, - line_feeder.linenr) + else: + unset_match = unset_re_match(line) + if not unset_match: continue - # Strip quotes and remove escapings. The unescaping - # procedure should be safe since " can only appear as \" - # inside the string. - val = val[1:-1].replace('\\"', '"') \ - .replace("\\\\", "\\") - - if sym._is_choice_sym: - user_mode = sym._parent._user_mode - if user_mode is not None and user_mode != val: - self._warn("assignment to {} changes mode of " - 'containing choice from "{}" to "{}".' - .format(name, val, user_mode), - line_feeder.filename, - line_feeder.linenr) - else: - unset_match = unset_re_match(line) - if not unset_match: - continue - - name = unset_match.group(1) - if name not in self._syms: - self._warn_undef_assign_load( - name, val, line_feeder.filename, line_feeder.linenr) - continue + name = unset_match.group(1) + if name not in syms: + self._warn_undef_assign_load(name, "n", filename, + linenr) + continue - sym = self._syms[name] - val = "n" + sym = syms[name] + val = "n" - # Done parsing the assignment. Set the value. + # Done parsing the assignment. Set the value. - if sym._user_val is not None: - self._warn('{} set more than once. Old value: "{}", new ' - 'value: "{}".' - .format(name, sym._user_val, val), - line_feeder.filename, line_feeder.linenr) + if sym.user_value is not None: + self._warn('{} set more than once. Old value: "{}", new ' + 'value: "{}".' + .format(name, sym.user_value, val), + filename, linenr) - sym._set_user_value_no_invalidate(val, True) + sym._set_value_no_invalidate(val, True) - def write_config(self, filename, header=None): - """Writes out symbol values in the familiar .config format. + def write_config(self, filename, + header="# Generated by Kconfiglib (https://github.com/ulfalizer/Kconfiglib)\n"): + """ + Writes out symbol values in .config format. - Kconfiglib makes sure the format matches what the C implementation - would generate, down to whitespace. This eases testing. + Kconfiglib makes sure the format matches what the C tools would + generate, down to whitespace. This eases testing. filename: The filename under which to save the configuration. - header (default: None): A textual header that will appear at the - beginning of the file, with each line commented out automatically. - Does not need to include a trailing newline. None means no - header.""" - - # Symbol._already_written is set to True when _add_config_strings() is - # called on a symbol, so that symbols defined in multiple locations - # only get one .config entry. We reset it prior to writing out a new - # .config. It only needs to be reset for defined symbols, because - # undefined symbols will never have _add_config_strings() called on - # them (because they do not appear in the block structure rooted at - # _top_block). - # - # The C implementation reuses _write_to_conf for this, but we cache - # _write_to_conf together with the value and don't invalidate cached - # values when writing .config files, so that won't work. - for sym in self._defined_syms: - sym._already_written = False - - # Build configuration. Avoiding string concatenation is worthwhile at - # least for PyPy. - config_strings = [] - add_fn = config_strings.append - for item in self._top_block: - item._add_config_strings(add_fn) - + header (default: "# Generated by Kconfiglib (https://github.com/ulfalizer/Kconfiglib)\n"): + Text that will be inserted verbatim at the beginning of the file. + You would usually want each line to start with '#' to make it a + comment, and include a final terminating newline. + """ with open(filename, "w") as f: - # Write header - if header is not None: - f.writelines(["#" + line - for line in (header + "\n").splitlines(True)]) - # Write configuration - f.writelines(config_strings) + f.write(header) + f.writelines(self._get_config_strings()) - def eval(self, s): - """Returns the value of the expression 's' -- where 's' is represented - as a string -- in the context of the configuration. Raises - Kconfig_Syntax_Error if syntax errors are detected in 's'. + def eval_string(self, s): + """ + Returns the value of the expression 's', represented as a string, in + the context of the configuration. Raises KconfigSyntaxError if syntax + errors are detected in 's'. - For example, if FOO and BAR are tristate symbols at least one of which - has the value "y", then config.eval("y && (FOO || BAR)") => "y" + As an example, if FOO and BAR are tristate symbols at least one of + which has the value "y", then config.eval_string("y && (FOO || BAR)") + returns "y". This function always yields a tristate value. To get the value of - non-bool, non-tristate symbols, use Symbol.get_value(). + non-bool, non-tristate symbols, use Symbol.value. The result of this function is consistent with how evaluation works for - conditional expressions in the configuration as well as in the C - implementation. "m" and m are rewritten as '"m" && MODULES' and 'm && - MODULES', respectively, and a result of "m" will get promoted to "y" if - we're running without modules. - - Syntax checking is somewhat lax, partly to be compatible with lax - parsing in the C implementation.""" - return self._eval_expr(self._parse_expr(self._tokenize(s, True), - None, # Current symbol/choice - s, - None, # filename - None, # linenr - True)) # transform_m - - def unset_user_values(self): - """Resets the values of all symbols, as if Config.load_config() or - Symbol.set_user_value() had never been called.""" - - # set_user_value() already rejects undefined symbols, and they don't + conditional ('if ...') expressions in the configuration (as well as in + the C tools). m is rewritten to 'm && MODULES'. + """ + return eval_expr(self._parse_expr(self._tokenize(s, True), + s, + None, # filename + None, # linenr + True)) # transform_m + + def unset_values(self): + """ + Resets the user values of all symbols, as if Config.load_config() or + Symbol.set_value() had never been called. + """ + + # set_value() already rejects undefined symbols, and they don't # need to be invalidated (because their value never changes), so we can # just iterate over defined symbols. - for sym in self._defined_syms: - # We're iterating over all symbols already, so no need for symbols - # to invalidate their dependent symbols - sym._unset_user_value_no_recursive_invalidate() + for sym in self.defined_syms: + # We're iterating over all symbols, so no need for symbols to + # invalidate their dependent symbols + sym.user_value = None + sym._invalidate() - def set_print_warnings(self, print_warnings): - """Determines whether warnings related to this configuration (for - things like attempting to assign illegal values to symbols with - Symbol.set_user_value()) should be printed to stderr. + for choice in self._choices: + choice.user_value = choice.user_selection = None + choice._invalidate() - print_warnings: True if warnings should be printed.""" - self._print_warnings = print_warnings + def enable_warnings(self): + """ + See Config.__init__(). + """ + self._print_warnings = True - def set_print_undef_assign(self, print_undef_assign): - """Determines whether informational messages related to assignments to - undefined symbols should be printed to stderr for this configuration. + def disable_warnings(self): + """ + See Config.__init__(). + """ + self._print_warnings = False - print_undef_assign: If True, such messages will be printed.""" - self._print_undef_assign = print_undef_assign + def enable_undef_warnings(self): + """ + Enables printing of warnings to stderr for assignments to undefined + symbols. Disabled by default since it tends to be spammy for Kernel + configurations (and mostly suggests cleanups). + """ + self._print_undef_assign = True - def __str__(self): - """Returns a string containing various information about the Config.""" - return _lines("Configuration", - "File : " + - self._kconfig_filename, - "Base directory : " + - self._base_dir, - "Value of $ARCH at creation time : " + - ("(not set)" - if self._arch is None - else self._arch), - "Value of $SRCARCH at creation time : " + - ("(not set)" - if self._srcarch is None - else self._srcarch), - "Value of $srctree at creation time : " + - ("(not set)" - if self._srctree is None - else self._srctree), - "Most recently loaded .config : " + - ("(no .config loaded)" - if self._config_filename is None - else self._config_filename), - "Print warnings : " + - str(self._print_warnings), - "Print assignments to undefined symbols : " + - str(self._print_undef_assign)) + def disable_undef_warnings(self): + """ + See enable_undef_assign(). + """ + self._print_undef_assign = False + + def __repr__(self): + """ + Prints some general information when a Config object is evaluated. + """ + fields = ( + "configuration with {} symbols".format(len(self.syms)), + 'main menu prompt "{}"'.format(self.mainmenu_text), + "srctree not set" if self.srctree is None else + 'srctree "{}"'.format(self.srctree), + 'config symbol prefix "{}"'.format(self.config_prefix), + "warnings " + ("enabled" if self._print_warnings else "disabled"), + "undef. symbol assignment warnings " + + ("enabled" if self._print_undef_assign else "disabled") + ) + + return "<{}>".format(", ".join(fields)) # # Private methods # # + # File reading + # + + def _open(self, filename): + """ + First tries to open 'filename', then '$srctree/filename' if $srctree + was set when the configuration was loaded. + """ + try: + return open(filename) + except IOError as e: + if not os.path.isabs(filename) and self.srctree is not None: + filename = os.path.join(self.srctree, filename) + try: + return open(filename) + except IOError as e2: + # This is needed for Python 3, because e2 is deleted after + # the try block: + # + # https://docs.python.org/3/reference/compound_stmts.html#the-try-statement + e = e2 + + raise IOError( + 'Could not open "{}" ({}: {}). Perhaps the $srctree ' + "environment variable (which was {}) is set incorrectly. Note " + "that the current value of $srctree is saved when the Config " + "instance is created (for consistency and to cleanly " + "separate instances)." + .format(filename, errno.errorcode[e.errno], e.strerror, + "unset" if self.srctree is None else + '"{}"'.format(self.srctree))) + + # # Kconfig parsing # - def _parse_file(self, filename, parent, deps, visible_if_deps, block): - """Parses the Kconfig file 'filename'. Appends the Items in the file - (and any file it sources) to the list passed in the 'block' parameter. - See _parse_block() for the meaning of the parameters.""" - self._parse_block(_FileFeed(filename), None, parent, deps, - visible_if_deps, block) + def _tokenize(self, s, for_eval, filename=None, linenr=None): + """ + Returns a _Feed instance containing tokens derived from the string 's'. + Registers any new symbols encountered (via _lookup_sym()). + + Tries to be reasonably speedy by processing chunks of text via regexes + and string operations where possible. This is a hotspot during parsing. + + for_eval: + True when parsing an expression for a call to Config.eval_string(), + in which case we should not treat the first token specially nor + register new symbols. + """ + + # Tricky implementation detail: While parsing a token, 'token' refers + # to the previous token. See _NOT_REF for why this is needed. + + if for_eval: + token = None + tokens = [] + + # The current index in the string being tokenized + i = 0 + + else: + # See comment at _initial_token_re_match definition + initial_token_match = _initial_token_re_match(s) + if not initial_token_match: + return None + + keyword = _get_keyword(initial_token_match.group(1)) + if keyword == _T_HELP: + # Avoid junk after "help", e.g. "---", being registered as a + # symbol + return _Feed((_T_HELP,)) + if keyword is None: + # We expect a keyword as the first token + _tokenization_error(s, filename, linenr) + + token = keyword + tokens = [keyword] + # The current index in the string being tokenized + i = initial_token_match.end() + + # Main tokenization loop (for tokens past the first one) + while i < len(s): + # Test for an identifier/keyword first. This is the most common + # case. + id_keyword_match = _id_keyword_re_match(s, i) + if id_keyword_match: + # We have an identifier or keyword + + # Jump past it + i = id_keyword_match.end() + + # Check what it is. lookup_sym() will take care of allocating + # new symbols for us the first time we see them. Note that + # 'token' still refers to the previous token. + + name = id_keyword_match.group(1) + keyword = _get_keyword(name) + if keyword is not None: + # It's a keyword + token = keyword + + elif token not in _STRING_LEX: + # It's a symbol + if name in ("n", "m", "y"): + # Always represent n, m, y as strings (constant + # symbols). This simplifies the expression logic. + token = name + else: + token = self._lookup_sym(name, for_eval) + + else: + # It's a case of missing quotes. For example, the + # following is accepted: + # + # menu unquoted_title + # + # config A + # tristate unquoted_prompt + # + # endmenu + token = name + + else: + # Not an identifier/keyword + + # Note: _id_keyword_match and _initial_token_match strip + # trailing whitespace, making it safe to assume s[i] is the + # start of a token here. We manually strip trailing whitespace + # below as well. + # + # An old version stripped whitespace in this spot instead, but + # that leads to some redundancy and would cause + # _id_keyword_match to be tried against just "\n" fairly often + # (because file.readlines() keeps newlines). + + c = s[i] + i += 1 + + if c in "\"'": + # String literal/constant symbol + if "\\" not in s: + # Fast path: If the string contains no backslashes, we + # can just find the matching quote. + end = s.find(c, i) + if end == -1: + _tokenization_error(s, filename, linenr) + token = s[i:end] + i = end + 1 + else: + # Slow path: This could probably be sped up, but it's a + # very unusual case anyway. + quote = c + val = "" + while 1: + if i >= len(s): + _tokenization_error(s, filename, linenr) + c = s[i] + if c == quote: + break + if c == "\\": + if i + 1 >= len(s): + _tokenization_error(s, filename, linenr) + val += s[i + 1] + i += 2 + else: + val += c + i += 1 + i += 1 + token = val + + elif c == "&": + # Invalid characters are ignored + if i >= len(s) or s[i] != "&": continue + token = _T_AND + i += 1 + + elif c == "|": + # Invalid characters are ignored + if i >= len(s) or s[i] != "|": continue + token = _T_OR + i += 1 + + elif c == "!": + if i < len(s) and s[i] == "=": + token = _T_UNEQUAL + i += 1 + else: + token = _T_NOT + + elif c == "=": + token = _T_EQUAL + + elif c == "(": + token = _T_OPEN_PAREN + + elif c == ")": + token = _T_CLOSE_PAREN + + elif c == "#": break # Comment + + # Very rare + elif c == "<": + if i < len(s) and s[i] == "=": + token = _T_LESS_EQUAL + i += 1 + else: + token = _T_LESS + + # Very rare + elif c == ">": + if i < len(s) and s[i] == "=": + token = _T_GREATER_EQUAL + i += 1 + else: + token = _T_GREATER + + else: + # Invalid characters are ignored + continue + + # Skip trailing whitespace + while i < len(s) and s[i].isspace(): + i += 1 + + tokens.append(token) + + return _Feed(tokens) + + def _parse_block(self, line_feeder, end_marker, parent, visible_if_deps, + prev_line, prev_node): + """ + Parses a block, which is the contents of either a file or an if, menu, + or choice statement. + + line_feeder: + A _FileFeed instance feeding lines from a file. The Kconfig language + is line-based in practice. + + end_marker: + The token that ends the block, e.g. _T_ENDIF ("endif") for ifs. None + for files. - def _parse_block(self, line_feeder, end_marker, parent, deps, - visible_if_deps, block): - """Parses a block, which is the contents of either a file or an if, - menu, or choice statement. Appends the Items to the list passed in the - 'block' parameter. + parent: + The parent menu node, corresponding to e.g. a menu or Choice. Can + also be a Symbol, due to automatic submenu creation from + dependencies. - line_feeder: A _FileFeed instance feeding lines from a file. The - Kconfig language is line-based in practice. + visible_if_deps: + 'visible if' dependencies from enclosing menus. Propagated to Symbol + and Choice prompts. - end_marker: The token that ends the block, e.g. _T_ENDIF ("endif") for - ifs. None for files. + prev_line: + A "cached" (line, tokens) tuple from having parsed a line earlier + that we realized belonged to a different construct. - parent: The enclosing menu or choice, or None if we're at the top - level. + prev_node: + The previous menu node. New nodes will be added after this one (by + modifying its 'next' pointer). - deps: Dependencies from enclosing menus, choices and ifs. + Through a trick, prev_node is also used to parse a list of children + (for a menu or Choice): After parsing the children, the 'next' + pointer is assigned to the 'list' pointer to "tilt up" the children + above the node. - visible_if_deps (default: None): 'visible if' dependencies from - enclosing menus. - block: The list to add items to.""" + Returns the final menu node in the block (or prev_node if the block is + empty). This allows for easy chaining. + """ while 1: - # See the _end_line description in Config.__init__() - if self._end_line is not None: - line = self._end_line - tokens = self._end_line_tokens - self._end_line = None + if prev_line is not None: + line, tokens = prev_line else: - line = line_feeder.get_next() + line = line_feeder.next() if line is None: if end_marker is not None: - raise Kconfig_Syntax_Error("Unexpected end of file " + - line_feeder.filename) - return + raise KconfigSyntaxError("Unexpected end of file " + + line_feeder.filename) + + # We have reached the end of the file. Terminate the final + # node and return it. + prev_node.next = None + return prev_node tokens = self._tokenize(line, False, line_feeder.filename, line_feeder.linenr) + if tokens is None: + continue - t0 = tokens.get_next() - if t0 is None: - continue + t0 = tokens.next() # Cases are ordered roughly by frequency, which speeds things up a # bit - # This also handles 'menuconfig'. See the comment in the token - # definitions. - if t0 == _T_CONFIG: + if t0 in (_T_CONFIG, _T_MENUCONFIG): # The tokenizer will automatically allocate a new Symbol object # for any new names it encounters, so we don't need to worry # about that here. - sym = tokens.get_next() + sym = tokens.next() - # Symbols defined in multiple places get the parent of their - # first definition. However, for symbols whose parents are - # choice statements, the choice statement takes precedence. - if not sym._is_defined or isinstance(parent, Choice): - sym._parent = parent - sym._is_defined = True + node = MenuNode() + node.config = self + node.item = sym + node.help = None + node.list = None + node.parent = parent + node.filename = line_feeder.filename + node.linenr = line_feeder.linenr + node.is_menuconfig = (t0 == _T_MENUCONFIG) - self._parse_properties(line_feeder, sym, deps, visible_if_deps) + prev_line = self._parse_properties(line_feeder, node, + visible_if_deps) - self._defined_syms.append(sym) - block.append(sym) + sym.nodes.append(node) + self.defined_syms.append(sym) + + # Tricky Python semantics: This assign prev_node.next before + # prev_node + prev_node.next = prev_node = node elif t0 == _T_SOURCE: - kconfig_file = tokens.get_next() + kconfig_file = tokens.next() exp_kconfig_file = self._expand_sym_refs(kconfig_file) - # Hack: Avoid passing on a "./" prefix in the common case of - # 'base_dir' defaulting to ".", just to give less awkward - # results from e.g. get_def/ref_locations(). Maybe this could - # be handled in a nicer way. - if self._base_dir == ".": - filename = exp_kconfig_file - else: - filename = os.path.join(self._base_dir, exp_kconfig_file) - - if not os.path.exists(filename): + try: + f = self._open(exp_kconfig_file) + except IOError as e: + # Extend the error message a bit in this case raise IOError( - '{}:{}: sourced file "{}" (expands to "{}") not ' - "found. Perhaps base_dir (argument to " - 'Config.__init__(), currently "{}") is set to the ' - "the wrong value. Also note that e.g. $FOO in a " - "'source' statement does not refer to the " - "environment variable FOO, but rather to the Kconfig " - "symbol FOO (which would commonly have " - "'option env=\"FOO\"' in its definition)." + "{}:{}: {} Also note that e.g. $FOO in a 'source' " + "statement does not refer to the environment " + "variable FOO, but rather to the Kconfig Symbol FOO " + "(which would commonly have 'option env=\"FOO\"' in " + "its definition)." .format(line_feeder.filename, line_feeder.linenr, - kconfig_file, exp_kconfig_file, - self._base_dir)) + e.message)) - # Add items to the same block - self._parse_file(filename, parent, deps, visible_if_deps, - block) + prev_node = self._parse_block(_FileFeed(f, exp_kconfig_file), + None, parent, visible_if_deps, + None, prev_node) + prev_line = None elif t0 == end_marker: - # We have reached the end of the block - return + # We have reached the end of the block. Terminate the final + # node and return it. + prev_node.next = None + return prev_node elif t0 == _T_IF: - # If statements are treated as syntactic sugar for adding - # dependencies to enclosed items and do not have an explicit - # object representation. - - dep_expr = self._parse_expr(tokens, None, line, - line_feeder.filename, - line_feeder.linenr, True) - # Add items to the same block - self._parse_block(line_feeder, _T_ENDIF, parent, - _make_and(dep_expr, deps), - visible_if_deps, block) + node = MenuNode() + node.item = None + node.prompt = None + node.parent = parent + node.filename = line_feeder.filename + node.linenr = line_feeder.linenr + node.dep = \ + _make_and(parent.dep, + self._parse_expr(tokens, line, + line_feeder.filename, + line_feeder.linenr, True)) + + self._parse_block(line_feeder, _T_ENDIF, node, visible_if_deps, + None, node) + node.list = node.next + + prev_line = None + + prev_node.next = prev_node = node - elif t0 == _T_COMMENT: - comment = Comment() - comment._config = self - comment._parent = parent - comment._filename = line_feeder.filename - comment._linenr = line_feeder.linenr - comment._text = tokens.get_next() + elif t0 == _T_MENU: + node = MenuNode() + node.config = self + node.item = MENU + node.visibility = None + node.parent = parent + node.filename = line_feeder.filename + node.linenr = line_feeder.linenr - self._parse_properties(line_feeder, comment, deps, - visible_if_deps) + prev_line = self._parse_properties(line_feeder, node, + visible_if_deps) + node.prompt = (tokens.next(), node.dep) - self._comments.append(comment) - block.append(comment) + self._parse_block(line_feeder, _T_ENDMENU, node, + _make_and(visible_if_deps, node.visibility), + prev_line, node) + node.list = node.next - elif t0 == _T_MENU: - menu = Menu() - menu._config = self - menu._parent = parent - menu._filename = line_feeder.filename - menu._linenr = line_feeder.linenr - menu._title = tokens.get_next() - - self._parse_properties(line_feeder, menu, deps, - visible_if_deps) - - # This needs to go before _parse_block() so that we get the - # proper menu ordering in the case of nested menus - self._menus.append(menu) - # Parse contents and put Items in menu._block - self._parse_block(line_feeder, _T_ENDMENU, menu, - menu._menu_dep, - _make_and(visible_if_deps, - menu._visible_if_expr), - menu._block) - - block.append(menu) + prev_line = None + + prev_node.next = prev_node = node + + elif t0 == _T_COMMENT: + node = MenuNode() + node.config = self + node.item = COMMENT + node.list = None + node.parent = parent + node.filename = line_feeder.filename + node.linenr = line_feeder.linenr + + prev_line = self._parse_properties(line_feeder, node, + visible_if_deps) + node.prompt = (tokens.next(), node.dep) + + prev_node.next = prev_node = node elif t0 == _T_CHOICE: - name = tokens.get_next() + name = tokens.next() if name is None: choice = Choice() self._choices.append(choice) else: # Named choice - choice = self._named_choices.get(name) + choice = self.named_choices.get(name) if choice is None: choice = Choice() - choice._name = name - self._named_choices[name] = choice self._choices.append(choice) + choice.name = name + self.named_choices[name] = choice - choice._config = self - choice._parent = parent + choice.config = self - choice._def_locations.append((line_feeder.filename, - line_feeder.linenr)) + node = MenuNode() + node.config = self + node.item = choice + node.help = None + node.parent = parent + node.filename = line_feeder.filename + node.linenr = line_feeder.linenr - self._parse_properties(line_feeder, choice, deps, - visible_if_deps) + prev_line = self._parse_properties(line_feeder, node, + visible_if_deps) + self._parse_block(line_feeder, _T_ENDCHOICE, node, + visible_if_deps, prev_line, node) + node.list = node.next - # Parse contents and put Items in choice._block - self._parse_block(line_feeder, _T_ENDCHOICE, choice, deps, - visible_if_deps, choice._block) + prev_line = None - choice._determine_actual_symbols() - - # If no type is specified for the choice, its type is that of - # the first choice item with a specified type - if choice._type == UNKNOWN: - for item in choice._actual_symbols: - if item._type != UNKNOWN: - choice._type = item._type - break + choice.nodes.append(node) - # Each choice item of UNKNOWN type gets the type of the choice - for item in choice._actual_symbols: - if item._type == UNKNOWN: - item._type = choice._type - - block.append(choice) + prev_node.next = prev_node = node elif t0 == _T_MAINMENU: - text = tokens.get_next() - if self._mainmenu_text is not None: - self._warn("overriding 'mainmenu' text. " - 'Old value: "{}", new value: "{}".' - .format(self._mainmenu_text, text), - line_feeder.filename, line_feeder.linenr) - self._mainmenu_text = text + self.top_menu.prompt = (tokens.next(), None) + self.top_menu.filename = line_feeder.filename + self.top_menu.linenr = line_feeder.linenr else: _parse_error(line, "unrecognized construct", line_feeder.filename, line_feeder.linenr) - def _parse_cond(self, tokens, stmt, line, filename, linenr): - """Parses an optional 'if <expr>' construct and returns the parsed - <expr>, or None if the next token is not _T_IF.""" - return self._parse_expr(tokens, stmt, line, filename, linenr, True) \ + def _parse_cond(self, tokens, line, filename, linenr): + """ + Parses an optional 'if <expr>' construct and returns the parsed <expr>, + or None if the next token is not _T_IF + """ + return self._parse_expr(tokens, line, filename, linenr, True) \ if tokens.check(_T_IF) else None - def _parse_val_and_cond(self, tokens, stmt, line, filename, linenr): - """Parses '<expr1> if <expr2>' constructs, where the 'if' part is - optional. Returns a tuple containing the parsed expressions, with - None as the second element if the 'if' part is missing.""" - return (self._parse_expr(tokens, stmt, line, filename, linenr, False), - self._parse_cond(tokens, stmt, line, filename, linenr)) - - def _parse_properties(self, line_feeder, stmt, deps, visible_if_deps): - """Parsing of properties for symbols, menus, choices, and comments. - Takes care of propagating dependencies from enclosing menus and ifs.""" - - # In case the symbol is defined in multiple locations, we need to - # remember what prompts, defaults, selects, implies, and ranges are new - # for this definition, as "depends on" should only apply to the local - # definition. - new_prompt = None - new_def_exprs = [] - new_selects = [] - new_implies = [] - new_ranges = [] - - # Dependencies from 'depends on' statements - depends_on_expr = None + def _parse_val_and_cond(self, tokens, line, filename, linenr): + """ + Parses '<expr1> if <expr2>' constructs, where the 'if' part is + optional. Returns a tuple containing the parsed expressions, with None + as the second element if the 'if' part is missing. + """ + return (self._parse_expr(tokens, line, filename, linenr, False), + self._parse_cond(tokens, line, filename, linenr)) + + def _parse_properties(self, line_feeder, node, visible_if_deps): + """ + Parses properties for symbols, menus, choices, and comments. Also takes + care of propagating dependencies from the menu node to the properties + of the item (this mirrors the inner working of the C tools). + + line_feeder: + A _FileFeed instance feeding lines from a file. The Kconfig language + is line-based in practice. + + node: + The menu node we're parsing properties on. Some properties (prompts, + help texts, 'depends on') apply to the Menu node, while the others + apply to the contained item. + + visible_if_deps: + 'visible if' dependencies from enclosing menus. Propagated to Symbol + and Choice prompts. + + Stops when finding a line that isn't part of the properties, and + returns a (line, tokens) tuple for it so it can be reused. + """ + + # New properties encountered at this location. A local 'depends on' + # only applies to these, in case a symbol is defined in multiple + # locations. + prompt = None + defaults = [] + selects = [] + implies = [] + ranges = [] + + # Menu node dependency from 'depends on'. Will get propagated to the + # properties above. + node.dep = None + + # The cached (line, tokens) tuple that we return + last_line = None while 1: - line = line_feeder.get_next() + line = line_feeder.next() if line is None: break @@ -889,138 +1015,147 @@ class Config(object): linenr = line_feeder.linenr tokens = self._tokenize(line, False, filename, linenr) - - t0 = tokens.get_next() - if t0 is None: + if tokens is None: continue - # Cases are ordered roughly by frequency, which speeds things up a - # bit + t0 = tokens.next() if t0 == _T_DEPENDS: if not tokens.check(_T_ON): _parse_error(line, 'expected "on" after "depends"', filename, linenr) - depends_on_expr = \ - _make_and(depends_on_expr, - self._parse_expr(tokens, stmt, line, filename, + node.dep = \ + _make_and(node.dep, + self._parse_expr(tokens, line, filename, linenr, True)) elif t0 == _T_HELP: # Find first non-blank (not all-space) line and get its # indentation - line = line_feeder.next_nonblank() + + while 1: + line = line_feeder.next_no_join() + if line is None or not line.isspace(): + break + if line is None: - stmt._help = "" + node.help = "" break + indent = _indentation(line) if indent == 0: # If the first non-empty lines has zero indent, there is no # help text - stmt._help = "" - line_feeder.unget() + node.help = "" + line_feeder.linenr -= 1 break # The help text goes on till the first non-empty line with less # indent - help_lines = [_deindent(line, indent)] + + help_lines = [_deindent(line, indent).rstrip()] while 1: - line = line_feeder.get_next() + line = line_feeder.next_no_join() if line is None or \ (not line.isspace() and _indentation(line) < indent): - stmt._help = "".join(help_lines) + node.help = "\n".join(help_lines).rstrip() + "\n" break - help_lines.append(_deindent(line, indent)) + help_lines.append(_deindent(line, indent).rstrip()) if line is None: break - line_feeder.unget() + line_feeder.linenr -= 1 elif t0 == _T_SELECT: - if not isinstance(stmt, Symbol): + if not isinstance(node.item, Symbol): _parse_error(line, "only symbols can select", filename, linenr) - new_selects.append( - (tokens.get_next(), - self._parse_cond(tokens, stmt, line, filename, linenr))) + # HACK: We always represent n/m/y using the constant symbol + # "n"/"m"/"y" forms, but that causes a crash if a Kconfig file + # does e.g. 'select n' (which is meaningless and probably stems + # from a misunderstanding). Seen in U-Boot. Just skip the + # select. + target = tokens.next() + if target not in ("n", "m", "y"): + selects.append( + (target, + self._parse_cond(tokens, line, filename, linenr))) elif t0 == _T_IMPLY: - if not isinstance(stmt, Symbol): + if not isinstance(node.item, Symbol): _parse_error(line, "only symbols can imply", filename, linenr) - new_implies.append( - (tokens.get_next(), - self._parse_cond(tokens, stmt, line, filename, linenr))) + # See above + target = tokens.next() + if target not in ("n", "m", "y"): + implies.append( + (target, + self._parse_cond(tokens, line, filename, linenr))) elif t0 in (_T_BOOL, _T_TRISTATE, _T_INT, _T_HEX, _T_STRING): - stmt._type = _TOKEN_TO_TYPE[t0] - if tokens.peek_next() is not None: - new_prompt = self._parse_val_and_cond(tokens, stmt, line, - filename, linenr) + node.item._type = _TOKEN_TO_TYPE[t0] + if tokens.peek() is not None: + prompt = self._parse_val_and_cond(tokens, line, + filename, linenr) elif t0 == _T_DEFAULT: - new_def_exprs.append( - self._parse_val_and_cond( - tokens, stmt, line, filename, linenr)) + defaults.append( + self._parse_val_and_cond(tokens, line, filename, linenr)) elif t0 in (_T_DEF_BOOL, _T_DEF_TRISTATE): - stmt._type = _TOKEN_TO_TYPE[t0] - if tokens.peek_next() is not None: - new_def_exprs.append( - self._parse_val_and_cond(tokens, stmt, line, filename, + node.item._type = _TOKEN_TO_TYPE[t0] + if tokens.peek() is not None: + defaults.append( + self._parse_val_and_cond(tokens, line, filename, linenr)) elif t0 == _T_PROMPT: # 'prompt' properties override each other within a single # definition of a symbol, but additional prompts can be added - # by defining the symbol multiple times; hence 'new_prompt' - # instead of 'prompt'. - new_prompt = self._parse_val_and_cond(tokens, stmt, line, - filename, linenr) + # by defining the symbol multiple times + prompt = self._parse_val_and_cond(tokens, line, filename, + linenr) elif t0 == _T_RANGE: - new_ranges.append( - (tokens.get_next(), - tokens.get_next(), - self._parse_cond(tokens, stmt, line, filename, linenr))) + ranges.append( + (tokens.next(), + tokens.next(), + self._parse_cond(tokens, line, filename, linenr))) elif t0 == _T_OPTION: if tokens.check(_T_ENV) and tokens.check(_T_EQUAL): - env_var = tokens.get_next() + env_var = tokens.next() - stmt._is_special = True - stmt._is_from_env = True + node.item.env_var = env_var if env_var not in os.environ: - self._warn("the symbol {} references the non-existent " - "environment variable {} and will get the " - "empty string as its value. If you're " - "using Kconfiglib via " - "'make (i)scriptconfig', it should have " - "set up the environment correctly for you. " - "If you still got this message, that " - "might be an error, and you should email " - "ulfalizer a.t Google's email service.""" - .format(stmt._name, env_var), + self._warn("the symbol {0} references the " + "non-existent environment variable {1} " + "(meaning the 'option env=\"{1}\"' will " + "have no effect). If you're using " + "Kconfiglib via 'make (i)scriptconfig', it " + "should have set up the environment " + "correctly for you. If you still got this " + "message, that might be an error, and you " + "should email ulfalizer a.t Google's email " + "service.".format(node.item.name, env_var), filename, linenr) - - stmt._cached_val = "" else: - stmt._cached_val = os.environ[env_var] + defaults.append((os.environ[env_var], None)) elif tokens.check(_T_DEFCONFIG_LIST): - if self._defconfig_sym is None: - self._defconfig_sym = stmt + if self.defconfig_list is None: + self.defconfig_list = node.item else: self._warn("'option defconfig_list' set on multiple " "symbols ({0} and {1}). Only {0} will be " "used." - .format(self._defconfig_sym._name, - stmt._name)) + .format(self.defconfig_list.name, + node.item.name)) elif tokens.check(_T_MODULES): # To reduce warning spam, only warn if 'option modules' is @@ -1028,7 +1163,7 @@ class Config(object): # safe. I haven't run into any projects that make use # modules besides the kernel yet, and there it's likely to # keep being called "MODULES". - if stmt._name != "MODULES": + if node.item is not self.modules: self._warn("the 'modules' option is not supported. " "Let me know if this is a problem for you; " "it shouldn't be that hard to implement. " @@ -1040,12 +1175,13 @@ class Config(object): filename, linenr) elif tokens.check(_T_ALLNOCONFIG_Y): - if not isinstance(stmt, Symbol): + if not isinstance(node.item, Symbol): _parse_error(line, "the 'allnoconfig_y' option is only " "valid for symbols", filename, linenr) - stmt._allnoconfig_y = True + + node.item.is_allnoconfig_y = True else: _parse_error(line, "unrecognized option", filename, linenr) @@ -1054,114 +1190,87 @@ class Config(object): if not tokens.check(_T_IF): _parse_error(line, 'expected "if" after "visible"', filename, linenr) - if not isinstance(stmt, Menu): - _parse_error(line, - "'visible if' is only valid for menus", - filename, linenr) - stmt._visible_if_expr = \ - _make_and(stmt._visible_if_expr, - self._parse_expr(tokens, stmt, line, filename, - linenr, True)) + node.visibility = \ + _make_and(node.visibility, + self._parse_expr(tokens, line, filename, linenr, + True)) elif t0 == _T_OPTIONAL: - if not isinstance(stmt, Choice): + if not isinstance(node.item, Choice): _parse_error(line, '"optional" is only valid for choices', filename, linenr) - stmt._optional = True + + node.item.is_optional = True else: - # See the _end_line description in Config.__init__() - self._end_line = line - tokens.unget_all() - self._end_line_tokens = tokens + tokens.i = 0 + last_line = (line, tokens) break # Done parsing properties. Now add the new - # prompts/defaults/selects/implies/ranges, with dependencies - # propagated. - - # Save original dependencies from enclosing menus and ifs - stmt._deps_from_containing = deps - - # The parent deps + the 'depends on' deps. This is also used to - # implicitly create menus when a symbol depends on the previous symbol, - # hence the name. In the C implementation, it's the dependency of a - # menu "node". - stmt._menu_dep = _make_and(deps, depends_on_expr) - - if isinstance(stmt, (Menu, Comment)): - # For display purposes - stmt._orig_deps = depends_on_expr - else: - # Symbol or Choice - - if isinstance(stmt, Symbol): - stmt._direct_deps = _make_or(stmt._direct_deps, stmt._menu_dep) - - # Propagate dependencies to prompts - if new_prompt is not None: - prompt, cond_expr = new_prompt - - # Propagate 'visible if' and 'depends on' - cond_expr = _make_and(_make_and(cond_expr, visible_if_deps), - depends_on_expr) - - # Version without parent dependencies, for display - stmt._orig_prompts.append((prompt, cond_expr)) - - # This is what we actually use for evaluation - stmt._prompts.append((prompt, _make_and(cond_expr, deps))) - - # Propagate dependencies to defaults - for val_expr, cond_expr in new_def_exprs: - # Version without parent dependencies, for display - stmt._orig_def_exprs.append( - (val_expr, _make_and(cond_expr, depends_on_expr))) - - # This is what we actually use for evaluation - stmt._def_exprs.append( - (val_expr, _make_and(cond_expr, stmt._menu_dep))) + # prompts/defaults/selects/implies/ranges properties, with dependencies + # from node.dep propagated. + + # First propagate parent dependencies to node.dep + node.dep = _make_and(node.dep, node.parent.dep) + + if isinstance(node.item, (Symbol, Choice)): + if isinstance(node.item, Symbol): + node.item.direct_deps = \ + _make_or(node.item.direct_deps, node.dep) + + # Set the prompt, with dependencies propagated + if prompt is not None: + node.prompt = (prompt[0], + _make_and(_make_and(prompt[1], node.dep), + visible_if_deps)) + else: + node.prompt = None - # Propagate dependencies to ranges - for low, high, cond_expr in new_ranges: - # Version without parent dependencies, for display - stmt._orig_ranges.append( - (low, high, _make_and(cond_expr, depends_on_expr))) + # Add the new defaults, with dependencies propagated + for val_expr, cond_expr in defaults: + node.item.defaults.append( + (val_expr, _make_and(cond_expr, node.dep))) - # This is what we actually use for evaluation - stmt._ranges.append( - (low, high, _make_and(cond_expr, stmt._menu_dep))) + # Add the new ranges, with dependencies propagated + for low, high, cond_expr in ranges: + node.item.ranges.append( + (low, high, _make_and(cond_expr, node.dep))) # Handle selects - for target, cond_expr in new_selects: - # Used for display - stmt._orig_selects.append( - (target, _make_and(cond_expr, depends_on_expr))) + for target, cond_expr in selects: + # Only stored for convenience. Not used during evaluation. + node.item.selects.append( + (target, _make_and(cond_expr, node.dep))) # Modify the dependencies of the selected symbol - target._rev_dep = \ - _make_or(target._rev_dep, - _make_and(stmt, _make_and(cond_expr, - stmt._menu_dep))) + target.rev_dep = \ + _make_or(target.rev_dep, + _make_and(node.item, + _make_and(cond_expr, node.dep))) # Handle implies - for target, cond_expr in new_implies: - # Used for display - stmt._orig_implies.append( - (target, _make_and(cond_expr, depends_on_expr))) + for target, cond_expr in implies: + # Only stored for convenience. Not used during evaluation. + node.item.implies.append( + (target, _make_and(cond_expr, node.dep))) # Modify the dependencies of the implied symbol - target._weak_rev_dep = \ - _make_or(target._weak_rev_dep, - _make_and(stmt, _make_and(cond_expr, - stmt._menu_dep))) - - def _parse_expr(self, feed, cur_item, line, filename, linenr, transform_m): - """Parses an expression from the tokens in 'feed' using a simple - top-down approach. The result has the form + target.weak_rev_dep = \ + _make_or(target.weak_rev_dep, + _make_and(node.item, + _make_and(cond_expr, node.dep))) + + # Return cached non-property line + return last_line + + def _parse_expr(self, feed, line, filename, linenr, transform_m): + """ + Parses an expression from the tokens in 'feed' using a simple top-down + approach. The result has the form '(<operator> <operand 1> <operand 2>)' where <operator> is e.g. kconfiglib._AND. If there is only one operand (i.e., no && or ||), then the operand is returned directly. This also goes for subexpressions. @@ -1170,22 +1279,24 @@ class Config(object): structure (_AND, A, (_AND, B, (_OR, (_NOT, C), (_EQUAL, D, 3)))), with the Symbol objects stored directly in the expression. - feed: _Feed instance containing the tokens for the expression. - - cur_item: The item (Symbol, Choice, Menu, or Comment) currently being - parsed, or None if we're not parsing an item. Used for recording - references to symbols. + feed: + _Feed instance containing the tokens for the expression. - line: The line containing the expression being parsed. + line: + The line containing the expression being parsed. - filename: The file containing the expression. None when using - Config.eval(). + filename: + The file containing the expression. None when using + Config.eval_string(). - linenr: The line number containing the expression. None when using - Config.eval(). + linenr: + The line number containing the expression. None when using + Config.eval_string(). - transform_m (default: False): Determines if 'm' should be rewritten to - 'm && MODULES'. See the Config.eval() docstring.""" + transform_m: + True if 'm' should be rewritten to 'm && MODULES'. See + the Config.eval_string() documentation. + """ # Grammar: # @@ -1211,8 +1322,8 @@ class Config(object): # we end up allocating a ton of lists instead of reusing expressions, # which is bad. - and_expr = self._parse_and_expr(feed, cur_item, line, filename, - linenr, transform_m) + and_expr = self._parse_and_expr(feed, line, filename, linenr, + transform_m) # Return 'and_expr' directly if we have a "single-operand" OR. # Otherwise, parse the expression on the right and make an _OR node. @@ -1220,54 +1331,47 @@ class Config(object): # (_OR, A, (_OR, B, (_OR, C, D))). return and_expr \ if not feed.check(_T_OR) else \ - (_OR, and_expr, self._parse_expr(feed, cur_item, line, filename, - linenr, transform_m)) - - def _parse_and_expr(self, feed, cur_item, line, filename, linenr, - transform_m): + (_OR, and_expr, self._parse_expr(feed, line, filename, linenr, + transform_m)) - factor = self._parse_factor(feed, cur_item, line, filename, linenr, - transform_m) + def _parse_and_expr(self, feed, line, filename, linenr, transform_m): + factor = self._parse_factor(feed, line, filename, linenr, transform_m) # Return 'factor' directly if we have a "single-operand" AND. # Otherwise, parse the right operand and make an _AND node. This turns # A && B && C && D into (_AND, A, (_AND, B, (_AND, C, D))). return factor \ if not feed.check(_T_AND) else \ - (_AND, factor, self._parse_and_expr(feed, cur_item, line, - filename, linenr, - transform_m)) + (_AND, factor, self._parse_and_expr(feed, line, filename, + linenr, transform_m)) - def _parse_factor(self, feed, cur_item, line, filename, linenr, - transform_m): - token = feed.get_next() + def _parse_factor(self, feed, line, filename, linenr, transform_m): + token = feed.next() if isinstance(token, (Symbol, str)): # Plain symbol or relation - next_token = feed.peek_next() - if next_token not in _TOKEN_TO_RELATION: + next_token = feed.peek() + if next_token not in _TOKEN_TO_REL: # Plain symbol # For conditional expressions ('depends on <expr>', # '... if <expr>', etc.), "m" and m are rewritten to # "m" && MODULES. - if transform_m and (token is self._m or token == "m"): - return (_AND, "m", self._lookup_sym("MODULES")) + if transform_m and token == "m": + return (_AND, "m", self.modules) return token # Relation - return (_TOKEN_TO_RELATION[feed.get_next()], - token, - feed.get_next()) + return (_TOKEN_TO_REL[feed.next()], token, feed.next()) if token == _T_NOT: - return (_NOT, self._parse_factor(feed, cur_item, line, filename, - linenr, transform_m)) + return (_NOT, self._parse_factor(feed, line, filename, linenr, + transform_m)) if token == _T_OPEN_PAREN: - expr_parse = self._parse_expr(feed, cur_item, line, filename, + expr_parse = self._parse_expr(feed, line, filename, linenr, transform_m) if not feed.check(_T_CLOSE_PAREN): _parse_error(line, "missing end parenthesis", filename, linenr) @@ -1275,338 +1379,104 @@ class Config(object): _parse_error(line, "malformed expression", filename, linenr) - def _tokenize(self, s, for_eval, filename=None, linenr=None): - """Returns a _Feed instance containing tokens derived from the string - 's'. Registers any new symbols encountered (via _lookup_sym()). - - Tries to be reasonably speedy by processing chunks of text via regexes - and string operations where possible. This is a hotspot during parsing. - - for_eval: True when parsing an expression for a call to Config.eval(), - in which case we should not treat the first token specially nor - register new symbols.""" - - # Tricky implementation detail: While parsing a token, 'token' refers - # to the previous token. See _NOT_REF for why this is needed. - - if for_eval: - token = None - tokens = [] - - # The current index in the string being tokenized - i = 0 - - else: - # See comment at _initial_token_re_match definition - initial_token_match = _initial_token_re_match(s) - if not initial_token_match: - return _Feed(()) - - keyword = _get_keyword(initial_token_match.group(1)) - if keyword == _T_HELP: - # Avoid junk after "help", e.g. "---", being registered as a - # symbol - return _Feed((_T_HELP,)) - if keyword is None: - # We expect a keyword as the first token - _tokenization_error(s, filename, linenr) - - token = keyword - tokens = [keyword] - # The current index in the string being tokenized - i = initial_token_match.end() - - # Main tokenization loop (for tokens past the first one) - while i < len(s): - # Test for an identifier/keyword first. This is the most common - # case. - id_keyword_match = _id_keyword_re_match(s, i) - if id_keyword_match: - # We have an identifier or keyword - - # Jump past it - i = id_keyword_match.end() - - # Check what it is. lookup_sym() will take care of allocating - # new symbols for us the first time we see them. Note that - # 'token' still refers to the previous token. - - name = id_keyword_match.group(1) - keyword = _get_keyword(name) - if keyword is not None: - # It's a keyword - token = keyword - - elif token not in _NOT_REF: - # It's a symbol reference - token = self._lookup_sym(name, for_eval) - token._ref_locations.append((filename, linenr)) - - elif token == _T_CONFIG: - # It's a symbol definition - token = self._lookup_sym(name, for_eval) - token._def_locations.append((filename, linenr)) - - else: - # It's a case of missing quotes. For example, the - # following is accepted: - # - # menu unquoted_title - # - # config A - # tristate unquoted_prompt - # - # endmenu - token = name - - else: - # Not an identifier/keyword - - # Note: _id_keyword_match and _initial_token_match strip - # trailing whitespace, making it safe to assume s[i] is the - # start of a token here. We manually strip trailing whitespace - # below as well. - # - # An old version stripped whitespace in this spot instead, but - # that leads to some redundancy and would cause - # _id_keyword_match to be tried against just "\n" fairly often - # (because file.readlines() keeps newlines). - - c = s[i] - i += 1 - - if c in "\"'": - # String literal/constant symbol - if "\\" not in s: - # Fast path: If the string contains no backslashes, we - # can just find the matching quote. - end = s.find(c, i) - if end == -1: - _tokenization_error(s, filename, linenr) - token = s[i:end] - i = end + 1 - else: - # Slow path: This could probably be sped up, but it's a - # very unusual case anyway. - quote = c - val = "" - while 1: - if i >= len(s): - _tokenization_error(s, filename, linenr) - c = s[i] - if c == quote: - break - if c == "\\": - if i + 1 >= len(s): - _tokenization_error(s, filename, linenr) - val += s[i + 1] - i += 2 - else: - val += c - i += 1 - i += 1 - token = val - - elif c == "&": - # Invalid characters are ignored - if i >= len(s) or s[i] != "&": continue - token = _T_AND - i += 1 - - elif c == "|": - # Invalid characters are ignored - if i >= len(s) or s[i] != "|": continue - token = _T_OR - i += 1 - - elif c == "!": - if i < len(s) and s[i] == "=": - token = _T_UNEQUAL - i += 1 - else: - token = _T_NOT - - elif c == "=": - token = _T_EQUAL - - elif c == "(": - token = _T_OPEN_PAREN - - elif c == ")": - token = _T_CLOSE_PAREN - - elif c == "#": break # Comment - - # Very rare - elif c == "<": - if i < len(s) and s[i] == "=": - token = _T_LESS_EQUAL - i += 1 - else: - token = _T_LESS - - # Very rare - elif c == ">": - if i < len(s) and s[i] == "=": - token = _T_GREATER_EQUAL - i += 1 - else: - token = _T_GREATER - - else: - # Invalid characters are ignored - continue - - # Skip trailing whitespace - while i < len(s) and s[i].isspace(): - i += 1 - - tokens.append(token) - - return _Feed(tokens) + # + # Symbol lookup + # def _lookup_sym(self, name, for_eval=False): - """Fetches the symbol 'name' from the symbol table, creating and + """ + Fetches the symbol 'name' from the symbol table, creating and registering it if it does not exist. If 'for_eval' is True, the symbol - won't be added to the symbol table if it does not exist -- this is for - Config.eval().""" - if name in self._syms: - return self._syms[name] - - new_sym = Symbol() - new_sym._config = self - new_sym._name = name + won't be added to the symbol table if it does not exist. This is for + Config.eval_string(). + """ + if name in self.syms: + return self.syms[name] + + sym = Symbol() + sym.config = self + sym.name = name if for_eval: self._warn("no symbol {} in configuration".format(name)) else: - self._syms[name] = new_sym - return new_sym + self.syms[name] = sym + return sym # - # Expression evaluation + # .config generation # - def _eval_expr(self, expr): - """Evaluates an expression to "n", "m", or "y".""" - - # Handles e.g. an "x if y" condition where the "if y" part is missing. - if expr is None: - return "y" - - res = self._eval_expr_rec(expr) - if res == "m": - # Promote "m" to "y" if we're running without modules. - # - # Internally, "m" is often rewritten to "m" && MODULES by both the - # C implementation and Kconfiglib, which takes care of cases where - # "m" should be demoted to "n" instead. - modules_sym = self._syms.get("MODULES") - if modules_sym is None or modules_sym.get_value() != "y": - return "y" - return res + def _get_config_strings(self): + """ + Returns a list containing all .config strings for the configuration. + """ - def _eval_expr_rec(self, expr): - if isinstance(expr, Symbol): - # Non-bool/tristate symbols are always "n" in a tristate sense, - # regardless of their value - return expr.get_value() if expr._type in (BOOL, TRISTATE) else "n" + config_strings = [] + add_fn = config_strings.append - if isinstance(expr, str): - return expr if expr in ("m", "y") else "n" + node = self.top_menu.list + if node is None: + # Empty configuration + return config_strings + + # Symbol._already_written is set to True when a symbol config string is + # fetched, so that symbols defined in multiple locations only get one + # .config entry. We reset it prior to writing out a new .config. It + # only needs to be reset for defined symbols, because undefined symbols + # will never be written out (because they do not appear structure + # rooted at Config.top_menu). + # + # The C tools reuse _write_to_conf for this, but we cache + # _write_to_conf together with the value and don't invalidate cached + # values when writing .config files, so that won't work. + for sym in self.defined_syms: + sym._already_written = False - if expr[0] == _AND: - ev1 = self._eval_expr_rec(expr[1]) - if ev1 == "n": - return "n" - ev2 = self._eval_expr_rec(expr[2]) - return ev2 if ev1 == "y" else \ - "m" if ev2 != "n" else \ - "n" - - if expr[0] == _OR: - ev1 = self._eval_expr_rec(expr[1]) - if ev1 == "y": - return "y" - ev2 = self._eval_expr_rec(expr[2]) - return ev2 if ev1 == "n" else \ - "y" if ev2 == "y" else \ - "m" - - if expr[0] == _NOT: - ev = self._eval_expr_rec(expr[1]) - return "n" if ev == "y" else \ - "y" if ev == "n" else \ - "m" - - if expr[0] in _RELATIONS: - # Implements <, <=, >, >= comparisons as well. These were added to - # kconfig in 31847b67 (kconfig: allow use of relations other than - # (in)equality). - - # This mirrors the C implementation pretty closely. Perhaps there's - # a more pythonic way to structure this. - - oper, op1, op2 = expr - op1_type, op1_str = _type_and_val(op1) - op2_type, op2_str = _type_and_val(op2) - - # If both operands are strings... - if op1_type == STRING and op2_type == STRING: - # ...then compare them lexicographically - comp = _strcmp(op1_str, op2_str) + while 1: + if isinstance(node.item, Symbol): + sym = node.item + if not sym._already_written: + config_string = sym.config_string + if config_string is not None: + add_fn(config_string) + sym._already_written = True + + elif (node.item == MENU and eval_expr(node.dep) != "n" and + eval_expr(node.visibility) != "n") or \ + (node.item == COMMENT and eval_expr(node.dep) != "n"): + add_fn("\n#\n# {}\n#\n".format(node.prompt[0])) + + # Iterative tree walk using parent pointers + + if node.list is not None: + node = node.list + elif node.next is not None: + node = node.next else: - # Otherwise, try to compare them as numbers - try: - comp = int(op1_str, _TYPE_TO_BASE[op1_type]) - \ - int(op2_str, _TYPE_TO_BASE[op2_type]) - except ValueError: - # They're not both valid numbers. If the comparison is - # anything but = or !=, return 'n'. Otherwise, reuse - # _strcmp() to check for (in)equality. - if oper not in (_EQUAL, _UNEQUAL): - return "n" - comp = _strcmp(op1_str, op2_str) - - if oper == _EQUAL: res = comp == 0 - elif oper == _UNEQUAL: res = comp != 0 - elif oper == _LESS: res = comp < 0 - elif oper == _LESS_EQUAL: res = comp <= 0 - elif oper == _GREATER: res = comp > 0 - elif oper == _GREATER_EQUAL: res = comp >= 0 - - return "y" if res else "n" - - _internal_error("Internal error while evaluating expression: " - "unknown operation {}.".format(expr[0])) - - def _eval_min(self, e1, e2): - """Returns the minimum value of the two expressions. Equates None with - 'y'.""" - e1_eval = self._eval_expr(e1) - e2_eval = self._eval_expr(e2) - return e1_eval if tri_less(e1_eval, e2_eval) else e2_eval - - def _eval_max(self, e1, e2): - """Returns the maximum value of the two expressions. Equates None with - 'y'.""" - e1_eval = self._eval_expr(e1) - e2_eval = self._eval_expr(e2) - return e1_eval if tri_greater(e1_eval, e2_eval) else e2_eval + while node.parent is not None: + node = node.parent + if node.next is not None: + node = node.next + break + else: + return config_strings # # Dependency tracking (for caching and invalidation) # def _build_dep(self): - """Populates the Symbol._direct_dependents sets, linking the symbol to - the symbols that immediately depend on it in the sense that changing - the value of the symbol might affect the values of those other symbols. + """ + Populates the Symbol._direct_dependents sets, linking the symbol to the + symbols that immediately depend on it in the sense that changing the + value of the symbol might affect the values of those other symbols. This is used for caching/invalidation purposes. The calculated sets might be larger than necessary as we don't do any complicated analysis - of the expressions.""" + of the expressions. + """ # Adds 'sym' as a directly dependent symbol to all symbols that appear - # in the expression 'e' + # in the expression 'expr' def add_expr_deps(expr, sym): res = [] _expr_syms(expr, res) @@ -1615,11 +1485,11 @@ class Config(object): # The directly dependent symbols of a symbol S are: # - # - Any symbols whose prompts, default values, _rev_dep (select - # condition), _weak_rev_dep (imply condition) or ranges depend on S + # - Any symbols whose prompts, default values, rev_dep (select + # condition), weak_rev_dep (imply condition), or ranges depend on S # # - Any symbol that has S as a direct dependency (has S in - # _direct_deps). This is needed to get invalidation right for + # direct_deps). This is needed to get invalidation right for # 'imply'. # # - Any symbols that belong to the same choice statement as S @@ -1634,307 +1504,62 @@ class Config(object): # change their value (they always evaluate to their name), so it's not # a true dependency. - for sym in self._defined_syms: - for _, e in sym._prompts: - add_expr_deps(e, sym) + for sym in self.defined_syms: + for node in sym.nodes: + if node.prompt is not None: + add_expr_deps(node.prompt[1], sym) - for v, e in sym._def_exprs: - add_expr_deps(v, sym) - add_expr_deps(e, sym) + for value, cond in sym.defaults: + add_expr_deps(value, sym) + add_expr_deps(cond, sym) - add_expr_deps(sym._rev_dep, sym) - add_expr_deps(sym._weak_rev_dep, sym) + add_expr_deps(sym.rev_dep, sym) + add_expr_deps(sym.weak_rev_dep, sym) - for l, u, e in sym._ranges: + for l, u, e in sym.ranges: add_expr_deps(l, sym) add_expr_deps(u, sym) add_expr_deps(e, sym) - add_expr_deps(sym._direct_deps, sym) + add_expr_deps(sym.direct_deps, sym) - if sym._is_choice_sym: - choice = sym._parent - for _, e in choice._prompts: - add_expr_deps(e, sym) - for _, e in choice._def_exprs: + if sym.choice is not None: + for node in sym.choice.nodes: + if node.prompt is not None: + add_expr_deps(node.prompt[1], sym) + for _, e in sym.choice.defaults: add_expr_deps(e, sym) - def _eq_to_sym(self, eq): - """_expr_depends_on() helper. For (in)equalities of the form sym = y/m - or sym != n, returns sym. For other (in)equalities, returns None.""" - relation, left, right = eq - - def transform_y_m_n(item): - if item is self._y: return "y" - if item is self._m: return "m" - if item is self._n: return "n" - return item - - left = transform_y_m_n(left) - right = transform_y_m_n(right) - - # Make sure the symbol (if any) appears to the left - if not isinstance(left, Symbol): - left, right = right, left - if not isinstance(left, Symbol): - return None - if (relation == _EQUAL and right in ("m", "y")) or \ - (relation == _UNEQUAL and right == "n"): - return left - return None - - def _expr_depends_on(self, expr, sym): - """Reimplementation of expr_depends_symbol() from mconf.c. Used to - determine if a submenu should be implicitly created, which influences - what items inside choice statements are considered choice items.""" - if expr is None: - return False - - def rec(expr): - if isinstance(expr, str): - return False - if isinstance(expr, Symbol): - return expr is sym - - if expr[0] in (_EQUAL, _UNEQUAL): - return self._eq_to_sym(expr) is sym - if expr[0] == _AND: - return rec(expr[1]) or rec(expr[2]) - return False - - return rec(expr) - def _invalidate_all(self): # Undefined symbols never change value and don't need to be # invalidated, so we can just iterate over defined symbols - for sym in self._defined_syms: + for sym in self.defined_syms: sym._invalidate() + for choice in self._choices: + choice._invalidate() + # # Printing and misc. # def _expand_sym_refs(self, s): - """Expands $-references to symbols in 's' to symbol values, or to the - empty string for undefined symbols.""" + """ + Expands $-references to symbols in 's' to symbol values, or to the + empty string for undefined symbols. + """ while 1: sym_ref_match = _sym_ref_re_search(s) if sym_ref_match is None: return s - sym = self._syms.get(sym_ref_match.group(1)) + sym = self.syms.get(sym_ref_match.group(1)) s = s[:sym_ref_match.start()] + \ - (sym.get_value() if sym is not None else "") + \ + (sym.value if sym is not None else "") + \ s[sym_ref_match.end():] - def _expr_val_str(self, expr, no_value_str="(none)", - get_val_instead_of_eval=False): - """Printing helper. Returns a string with 'expr' and its value. - - no_value_str: String to return when 'expr' is missing (None). - - get_val_instead_of_eval: Assume 'expr' is a symbol or string (constant - symbol) and get its value directly instead of evaluating it to a - tristate value.""" - - if expr is None: - return no_value_str - - if get_val_instead_of_eval: - if isinstance(expr, str): - return _expr_to_str(expr) - val = expr.get_value() - else: - val = self._eval_expr(expr) - - return "{} (value: {})".format(_expr_to_str(expr), _expr_to_str(val)) - - def _get_sym_or_choice_str(self, sc): - """Symbols and choices have many properties in common, so we factor out - common __str__() stuff here. "sc" is short for "symbol or choice".""" - - # As we deal a lot with string representations here, use some - # convenient shorthand: - s = _expr_to_str - - # - # Common symbol/choice properties - # - - user_val_str = "(no user value)" if sc._user_val is None else \ - s(sc._user_val) - - # Build prompts string - if not sc._prompts: - prompts_str = " (no prompts)" - else: - prompts_str_rows = [] - for prompt, cond_expr in sc._orig_prompts: - prompts_str_rows.append( - ' "{}"'.format(prompt) - if cond_expr is None else - ' "{}" if {}'.format(prompt, - self._expr_val_str(cond_expr))) - prompts_str = "\n".join(prompts_str_rows) - - # Build locations string - locations_str = "(no locations)" \ - if not sc._def_locations else \ - " ".join(["{}:{}".format(filename, linenr) - for filename, linenr in sc._def_locations]) - - # Build additional-dependencies-from-menus-and-ifs string - additional_deps_str = " " + \ - self._expr_val_str(sc._deps_from_containing, - "(no additional dependencies)") - - # - # Symbol-specific stuff - # - - if isinstance(sc, Symbol): - # Build ranges string - if isinstance(sc, Symbol): - if not sc._orig_ranges: - ranges_str = " (no ranges)" - else: - ranges_str_rows = [] - for l, u, cond_expr in sc._orig_ranges: - ranges_str_rows.append( - " [{}, {}]".format(s(l), s(u)) - if cond_expr is None else - " [{}, {}] if {}" - .format(s(l), s(u), self._expr_val_str(cond_expr))) - ranges_str = "\n".join(ranges_str_rows) - - # Build default values string - if not sc._orig_def_exprs: - defaults_str = " (no default values)" - else: - defaults_str_rows = [] - for val_expr, cond_expr in sc._orig_def_exprs: - row_str = " " + self._expr_val_str(val_expr, "(none)", - sc._type == STRING) - defaults_str_rows.append(row_str) - defaults_str_rows.append(" Condition: " + - self._expr_val_str(cond_expr)) - defaults_str = "\n".join(defaults_str_rows) - - # Build selects string - if not sc._orig_selects: - selects_str = " (no selects)" - else: - selects_str_rows = [] - for target, cond_expr in sc._orig_selects: - selects_str_rows.append( - " " + target._name - if cond_expr is None else - " {} if {}".format(target._name, - self._expr_val_str(cond_expr))) - selects_str = "\n".join(selects_str_rows) - - # Build implies string - if not sc._orig_implies: - implies_str = " (no implies)" - else: - implies_str_rows = [] - for target, cond_expr in sc._orig_implies: - implies_str_rows.append( - " " + target._name - if cond_expr is None else - " {} if {}".format(target._name, - self._expr_val_str(cond_expr))) - implies_str = "\n".join(implies_str_rows) - - res = _lines("Symbol " + - ("(no name)" if sc._name is None else sc._name), - "Type : " + _TYPENAME[sc._type], - "Value : " + s(sc.get_value()), - "User value : " + user_val_str, - "Visibility : " + s(_get_visibility(sc)), - "Is choice item : " + str(sc._is_choice_sym), - "Is defined : " + str(sc._is_defined), - "Is from env. : " + str(sc._is_from_env), - "Is special : " + str(sc._is_special), - "") - if sc._ranges: - res += _lines("Ranges:", ranges_str + "\n") - res += _lines("Prompts:", - prompts_str, - "Default values:", - defaults_str, - "Selects:", - selects_str, - "Implies:", - implies_str, - "Reverse (select-related) dependencies:", - " (no reverse dependencies)" - if sc._rev_dep == "n" - else " " + self._expr_val_str(sc._rev_dep), - "Weak reverse (imply-related) dependencies:", - " (no weak reverse dependencies)" - if sc._weak_rev_dep == "n" - else " " + self._expr_val_str(sc._weak_rev_dep), - "Additional dependencies from enclosing menus " - "and ifs:", - additional_deps_str, - "Locations: " + locations_str) - - return res - - # - # Choice-specific stuff - # - - # Build selected symbol string - sel = sc.get_selection() - sel_str = "(no selection)" if sel is None else sel._name - - # Build default values string - if not sc._def_exprs: - defaults_str = " (no default values)" - else: - defaults_str_rows = [] - for sym, cond_expr in sc._orig_def_exprs: - defaults_str_rows.append( - " " + sym._name - if cond_expr is None else - " {} if {}".format(sym._name, - self._expr_val_str(cond_expr))) - defaults_str = "\n".join(defaults_str_rows) - - # Build contained symbols string - names = [sym._name for sym in sc._actual_symbols] - syms_string = " ".join(names) if names else "(empty)" - - return _lines("Choice", - "Name (for named choices): " + - ("(no name)" if sc._name is None else sc._name), - "Type : " + _TYPENAME[sc._type], - "Selected symbol : " + sel_str, - "User value : " + user_val_str, - "Mode : " + s(sc.get_mode()), - "Visibility : " + s(_get_visibility(sc)), - "Optional : " + str(sc._optional), - "Prompts:", - prompts_str, - "Defaults:", - defaults_str, - "Choice symbols:", - " " + syms_string, - "Additional dependencies from enclosing menus and ifs:", - additional_deps_str, - "Locations: " + locations_str) - - def _is_header_line(self, line): - """Returns True is the line could be part of the initial header in a - .config file (which is really just another comment, but can be handy - for storing metadata).""" - return line is not None and line.startswith("#") and \ - not self._unset_re.match(line) - # # Warnings # @@ -1945,136 +1570,228 @@ class Config(object): _stderr_msg("warning: " + msg, filename, linenr) def _warn_undef_assign(self, msg, filename=None, linenr=None): - """For printing warnings for assignments to undefined variables. We - treat this is a separate category of warnings to avoid spamming lots of - warnings.""" + """ + See the class documentation. + """ if self._print_undef_assign: _stderr_msg("warning: " + msg, filename, linenr) def _warn_undef_assign_load(self, name, val, filename, linenr): - """Special version for load_config().""" + """ + Special version for load_config(). + """ self._warn_undef_assign( 'attempt to assign the value "{}" to the undefined symbol {}' \ .format(val, name), filename, linenr) -class Item(object): - - """Base class for symbols and other Kconfig constructs. Subclasses are - Symbol, Choice, Menu, and Comment.""" - - def is_symbol(self): - """Returns True if the item is a symbol. Short for - isinstance(item, kconfiglib.Symbol).""" - return isinstance(self, Symbol) - - def is_choice(self): - """Returns True if the item is a choice. Short for - isinstance(item, kconfiglib.Choice).""" - return isinstance(self, Choice) - - def is_menu(self): - """Returns True if the item is a menu. Short for - isinstance(item, kconfiglib.Menu).""" - return isinstance(self, Menu) - - def is_comment(self): - """Returns True if the item is a comment. Short for - isinstance(item, kconfiglib.Comment).""" - return isinstance(self, Comment) - -class Symbol(Item): - - """Represents a configuration symbol - e.g. FOO for - - config FOO - ...""" +class Symbol(object): + """ + Represents a configuration symbol: + + (menu)config FOO + ... + + The following attributes are available on Symbol instances. They should be + viewed as read-only, and some are implemented through @property magic (but + are still efficient to access due to internal caching). + + (Note: Prompts and help texts are stored in the Symbol's MenuNode(s) rather + than the Symbol itself. This matches the C tools.) + + name: + The name of the symbol, e.g. "FOO" for 'config FOO'. + + type: + The type of the symbol. One of BOOL, TRISTATE, STRING, INT, HEX, UNKNOWN. + UNKNOWN is for undefined symbols and symbols defined without a type. + + When running without modules (CONFIG_MODULES=n), TRISTATE symbols + magically change type to BOOL. This also happens for symbols within + choices in "y" mode. This matches the C tools, and makes sense for + menuconfig-like functionality. (Check the implementation of the property + if you need to get the original type.) + + value: + The current value of the symbol. Automatically recalculated as + dependencies change. + + assignable: + A string containing the tristate values that can be assigned to the + symbol, ordered from lowest (n) to highest (y). This corresponds to the + selections available in the 'menuconfig' interface. The assignable + values are calculated from the Symbol's visibility and selects/implies. + + Returns the empty string for non-BOOL/TRISTATE and symbols with + visibility "n". The other possible values are "ny", "nmy", "my", "m", + and "y". A "m" or "y" result means the symbol is visible but "locked" to + that particular value (through a select, perhaps in combination with a + prompt dependency). menuconfig seems to represent this as -M- and -*-, + respectively. + + Some handy 'assignable' idioms: + + # Is the symbol assignable (visible)? + if sym.assignable: + # What's the highest value it can be assigned? [-1] in Python + # gives the last element. + sym_high = sym.assignable[-1] + + # The lowest? + sym_low = sym.assignable[0] + + # Can the symbol be assigned the value "m"? + if "m" in sym.assignable: + ... + + visibility: + The visibility of the symbol's prompt(s): one of "n", "m", or "y". This + acts as an upper bound on the values the user can set for the symbol (via + Symbol.set_value() or a .config file). User values higher than the + visibility are truncated down to the visibility. + + If the visibility is "n", the user value is ignored, and the symbol is + not visible in e.g. the menuconfig interface. The visibility of symbols + without prompts is always "n". Symbols with "n" visibility can only get a + non-"n" value through a default, select, or imply. + + Note that 'depends on' and parent dependencies (including 'visible if' + dependencies) are propagated to the prompt dependencies. Additional + dependencies can be specified with e.g. 'bool "foo" if <cond>". + + user_value: + The value assigned with Symbol.set_value(), or None if no value has been + assigned. This won't necessarily match 'value' even if set, as + dependencies and prompt visibility take precedence. + + Note that you should use Symbol.set_value() to change this value. + Properties are always read-only. + + config_string: + The .config assignment string that would get written out for the symbol + by Config.write_config(). None if no .config assignment would get written + out. In general, visible symbols, symbols with (active) defaults, and + selected symbols get written out. + + nodes: + A list of MenuNode's for this symbol. For most symbols, this list will + contain a single MenuNode. Undefined symbols get an empty list, and + symbols defined in multiple locations get one node for each location. + + choice: + Holds the parent Choice for choice symbols, and None for non-choice + symbols. Doubles as a flag for whether a symbol is a choice symbol. + + defaults: + List of (default, cond) tuples for the symbol's 'default's. For example, + 'default A && B if C || D' is represented as ((AND, A, B), (OR, C, D)). + If there is no condition, 'cond' is None. + + Note that 'depends on' and parent dependencies are propagated to + 'default' conditions. + + selects: + List of (symbol, cond) tuples for the symbol's 'select's. For example, + 'select A if B' is represented as (A, B). If there is no condition, + 'cond' is None. + + Note that 'depends on' and parent dependencies are propagated to 'select' + conditions. + + implies: + List of (symbol, cond) tuples for the symbol's 'imply's. For example, + 'imply A if B' is represented as (A, B). If there is no condition, 'cond' + is None. + + Note that 'depends on' and parent dependencies are propagated to 'imply' + conditions. + + ranges: + List of (low, high, cond) tuples for the symbol's 'range's. For example, + 'range 1 2 if A' is represented as (1, 2, A). If there is no condition, + 'cond' is None. + + Note that 'depends on' and parent dependencies are propagated to 'range' + conditions. + + Gotcha: Integers are represented as Symbols too. Undefined symbols get + their name as their value, so this works out. The C tools work the same + way. + + rev_dep: + Reverse dependency expression from being 'select'ed by other symbols. + Multiple selections get ORed together. A condition on a select is ANDed + with the selecting symbol. For example, if A has 'select FOO' and B has + 'select FOO if C', then FOO's rev_dep will be '(OR, A, (AND, B, C))'. + + weak_rev_dep: + Like rev_dep, for imply. + + direct_deps: + The 'depends on' dependencies. If a symbol is defined in multiple + locations, the dependencies at each location are ORed together. + + env_var: + If the Symbol is set from the environment via 'option env="FOO"', this + contains the name ("FOO") of the environment variable. None for symbols + that aren't set from the environment. + + Internally, this is only used to print the symbol. The value of the + environment variable is looked up once when the configuration is parsed. + + is_allnoconfig_y: + True if the symbol has 'option allnoconfig_y' set on it. This has no + effect internally, but can be checked by scripts. + + config: + The Config instance this symbol is from. + """ + + __slots__ = ( + "_already_written", + "_cached_assignable", + "_cached_deps", + "_cached_val", + "_cached_vis", + "_direct_dependents", + "_type", + "_write_to_conf", + "choice", + "config", + "defaults", + "direct_deps", + "env_var", + "implies", + "is_allnoconfig_y", + "name", + "nodes", + "ranges", + "rev_dep", + "selects", + "user_value", + "weak_rev_dep", + ) # # Public interface # - def get_config(self): - """Returns the Config instance this symbol is from.""" - return self._config - - def get_name(self): - """Returns the name of the symbol.""" - return self._name - - def get_type(self): - """Returns the type of the symbol: one of UNKNOWN, BOOL, TRISTATE, - STRING, HEX, or INT. These are defined at the top level of the module, - so you'd do something like + @property + def type(self): + """ + See the class documentation. + """ - if sym.get_type() == kconfiglib.STRING: - ...""" + if self._type == TRISTATE and \ + ((self.choice is not None and self.choice.value == "y") or + self.config.modules.value == "n"): + return BOOL return self._type - def get_prompts(self): - """Returns a list of prompts defined for the symbol, in the order they - appear in the configuration files. Returns the empty list for symbols - with no prompt. - - This list will have a single entry for the vast majority of symbols - having prompts, but having multiple prompts for a single symbol is - possible through having multiple 'config' entries for it.""" - return [prompt for prompt, _ in self._orig_prompts] - - def get_help(self): - """Returns the help text of the symbol, or None if the symbol has no - help text.""" - return self._help - - def get_parent(self): - """Returns the menu or choice statement that contains the symbol, or - None if the symbol is at the top level. Note that if statements are - treated as syntactic and do not have an explicit class - representation.""" - return self._parent - - def get_def_locations(self): - """Returns a list of (filename, linenr) tuples, where filename (string) - and linenr (int) represent a location where the symbol is defined. For - the vast majority of symbols this list will only contain one element. - For the following Kconfig, FOO would get two entries: the lines marked - with *. - - config FOO * - bool "foo prompt 1" - - config FOO * - bool "foo prompt 2" + @property + def value(self): """ - return self._def_locations - - def get_ref_locations(self): - """Returns a list of (filename, linenr) tuples, where filename (string) - and linenr (int) represent a location where the symbol is referenced in - the configuration. For example, the lines marked by * would be included - for FOO below: - - config A - bool - default BAR || FOO * - - config B - tristate - depends on FOO * - default m if FOO * - - if FOO * - config A - bool "A" - endif - - config FOO (definition not included) - bool + See the class documentation. """ - return self._ref_locations - - def get_value(self): - """Calculate and return the value of the symbol. See also - Symbol.set_user_value().""" if self._cached_val is not None: return self._cached_val @@ -2083,48 +1800,48 @@ class Symbol(Item): # value. This is why things like "FOO = bar" work for seeing if FOO has # the value "bar". if self._type == UNKNOWN: - self._cached_val = self._name - return self._name + self._cached_val = self.name + return self.name # This will hold the value at the end of the function val = _DEFAULT_VALUE[self._type] - vis = _get_visibility(self) + vis = self.visibility if self._type in (BOOL, TRISTATE): - if not self._is_choice_sym: + if self.choice is None: self._write_to_conf = (vis != "n") - if vis != "n" and self._user_val is not None: + if vis != "n" and self.user_value is not None: # If the symbol is visible and has a user value, we use # that - val = self._config._eval_min(self._user_val, vis) + val = _eval_min(self.user_value, vis) else: # Otherwise, we look at defaults and weak reverse # dependencies (implies) - for def_expr, cond_expr in self._def_exprs: - cond_val = self._config._eval_expr(cond_expr) + for default, cond in self.defaults: + cond_val = eval_expr(cond) if cond_val != "n": self._write_to_conf = True - val = self._config._eval_min(def_expr, cond_val) + val = _eval_min(default, cond_val) break # Weak reverse dependencies are only considered if our # direct dependencies are met - if self._config._eval_expr(self._direct_deps) != "n": + if eval_expr(self.direct_deps) != "n": weak_rev_dep_val = \ - self._config._eval_expr(self._weak_rev_dep) + eval_expr(self.weak_rev_dep) if weak_rev_dep_val != "n": self._write_to_conf = True - val = self._config._eval_max(val, weak_rev_dep_val) + val = _eval_max(val, weak_rev_dep_val) # Reverse (select-related) dependencies take precedence - rev_dep_val = self._config._eval_expr(self._rev_dep) + rev_dep_val = eval_expr(self.rev_dep) if rev_dep_val != "n": self._write_to_conf = True - val = self._config._eval_max(val, rev_dep_val) + val = _eval_max(val, rev_dep_val) else: # (bool/tristate) symbol in choice. See _get_visibility() for @@ -2134,33 +1851,31 @@ class Symbol(Item): self._write_to_conf = False if vis != "n": - choice = self._parent - mode = choice.get_mode() + mode = self.choice.value if mode != "n": self._write_to_conf = True if mode == "y": - val = "y" if choice.get_selection() is self \ - else "n" - elif self._user_val in ("m", "y"): - # mode == "m" here + val = "y" if self.choice.selection is self else "n" + elif self.user_value in ("m", "y"): + # mode == "m" and self.user_value is not None or + # "n" val = "m" - # We need to promote "m" to "y" in two circumstances: + # "m" is promoted to "y" in two circumstances: # 1) If our type is boolean - # 2) If our _weak_rev_dep (from IMPLY) is "y" + # 2) If our weak_rev_dep (from IMPLY) is "y" if val == "m" and \ - (self._type == BOOL or - self._config._eval_expr(self._weak_rev_dep) == "y"): + (self.type == BOOL or eval_expr(self.weak_rev_dep) == "y"): val = "y" elif self._type in (INT, HEX): base = _TYPE_TO_BASE[self._type] # Check if a range is in effect - for low_expr, high_expr, cond_expr in self._ranges: - if self._config._eval_expr(cond_expr) != "n": + for low_expr, high_expr, cond_expr in self.ranges: + if eval_expr(cond_expr) != "n": has_active_range = True low_str = _str_val(low_expr) @@ -2177,21 +1892,21 @@ class Symbol(Item): self._write_to_conf = (vis != "n") - if vis != "n" and self._user_val is not None and \ - _is_base_n(self._user_val, base) and \ + if vis != "n" and self.user_value is not None and \ + _is_base_n(self.user_value, base) and \ (not has_active_range or - low <= int(self._user_val, base) <= high): + low <= int(self.user_value, base) <= high): # If the user value is well-formed and satisfies range # contraints, it is stored in exactly the same form as # specified in the assignment (with or without "0x", etc.) - val = self._user_val + val = self.user_value else: # No user value or invalid user value. Look at defaults. - for val_expr, cond_expr in self._def_exprs: - if self._config._eval_expr(cond_expr) != "n": + for val_expr, cond_expr in self.defaults: + if eval_expr(cond_expr) != "n": self._write_to_conf = True # Similarly to above, well-formed defaults are @@ -2227,11 +1942,11 @@ class Symbol(Item): elif self._type == STRING: self._write_to_conf = (vis != "n") - if vis != "n" and self._user_val is not None: - val = self._user_val + if vis != "n" and self.user_value is not None: + val = self.user_value else: - for val_expr, cond_expr in self._def_exprs: - if self._config._eval_expr(cond_expr) != "n": + for val_expr, cond_expr in self.defaults: + if eval_expr(cond_expr) != "n": self._write_to_conf = True val = _str_val(val_expr) break @@ -2239,480 +1954,319 @@ class Symbol(Item): self._cached_val = val return val - def get_user_value(self): - """Returns the value assigned to the symbol in a .config or via - Symbol.set_user_value() (provided the value was valid for the type of - the symbol). Returns None in case of no user value.""" - return self._user_val + @property + def assignable(self): + """ + See the class documentation. + """ + if self._cached_assignable is not None: + return self._cached_assignable - def get_upper_bound(self): - """For string/hex/int symbols and for bool and tristate symbols that - cannot be modified (see is_modifiable()), returns None. + self._cached_assignable = self._get_assignable() + return self._cached_assignable - Otherwise, returns the highest value the symbol can be set to with - Symbol.set_user_value() (that will not be truncated): one of "m" or - "y", arranged from lowest to highest. This corresponds to the highest - value the symbol could be given in e.g. the 'make menuconfig' - interface. + @property + def visibility(self): + """ + See the class documentation. + """ + if self._cached_vis is not None: + return self._cached_vis - See also the tri_less*() and tri_greater*() functions, which could come - in handy.""" - if self._type not in (BOOL, TRISTATE): - return None + self._cached_vis = _get_visibility(self) + return self._cached_vis - # Fast path for the common case - if self._rev_dep == "n": - vis = _get_visibility(self) - return vis if vis != "n" else None + @property + def config_string(self): + """ + See the class documentation. + """ - rev_dep_val = self._config._eval_expr(self._rev_dep) - # A bool selected to "m" gets promoted to "y", pinning it - if rev_dep_val == "m" and self._type == BOOL: + if self.env_var is not None: + # Variables with 'option env' never get written out. This + # corresponds to the SYMBOL_AUTO flag in the C implementation. return None - vis = _get_visibility(self) - return vis if tri_greater(vis, rev_dep_val) else None - - def get_lower_bound(self): - """For string/hex/int symbols and for bool and tristate symbols that - cannot be modified (see is_modifiable()), returns None. - - Otherwise, returns the lowest value the symbol can be set to with - Symbol.set_user_value() (that will not be truncated): one of "n" or - "m", arranged from lowest to highest. This corresponds to the lowest - value the symbol could be given in e.g. the 'make menuconfig' - interface. - See also the tri_less*() and tri_greater*() functions, which could come - in handy.""" - if self._type not in (BOOL, TRISTATE): - return None - rev_dep_val = self._config._eval_expr(self._rev_dep) - # A bool selected to "m" gets promoted to "y", pinning it - if rev_dep_val == "m" and self._type == BOOL: + # Note: _write_to_conf is determined when the value is calculated + val = self.value + if not self._write_to_conf: return None - return rev_dep_val if tri_greater(_get_visibility(self), rev_dep_val) \ - else None - def get_assignable_values(self): - """For string/hex/int symbols and for bool and tristate symbols that - cannot be modified (see is_modifiable()), returns the empty list. + if self._type in (BOOL, TRISTATE): + return "{}{}={}\n" \ + .format(self.config.config_prefix, self.name, val) \ + if val != "n" else \ + "# {}{} is not set\n" \ + .format(self.config.config_prefix, self.name) - Otherwise, returns a list containing the user values that can be - assigned to the symbol (that won't be truncated). Usage example: + if self._type in (INT, HEX): + return "{}{}={}\n" \ + .format(self.config.config_prefix, self.name, val) - if "m" in sym.get_assignable_values(): - sym.set_user_value("m") + if self._type == STRING: + # Escape \ and " + return '{}{}="{}"\n' \ + .format(self.config.config_prefix, self.name, + val.replace("\\", "\\\\").replace('"', '\\"')) - This is basically a more convenient interface to - get_lower/upper_bound() when wanting to test if a particular tristate - value can be assigned.""" - if self._type not in (BOOL, TRISTATE): - return [] - rev_dep_val = self._config._eval_expr(self._rev_dep) - # A bool selected to "m" gets promoted to "y", pinning it - if rev_dep_val == "m" and self._type == BOOL: - return [] - res = ["n", "m", "y"][_TRI_TO_INT[rev_dep_val] : - _TRI_TO_INT[_get_visibility(self)] + 1] - return res if len(res) > 1 else [] - - def get_visibility(self): - """Returns the visibility of the symbol: one of "n", "m" or "y". For - bool and tristate symbols, this is an upper bound on the value users - can set for the symbol. For other types of symbols, a visibility of "n" - means the user value will be ignored. A visibility of "n" corresponds - to not being visible in the 'make *config' interfaces. - - Example (assuming we're running with modules enabled -- i.e., MODULES - set to 'y'): - - # Assume this has been assigned 'n' - config N_SYM - tristate "N_SYM" - - # Assume this has been assigned 'm' - config M_SYM - tristate "M_SYM" - - # Has visibility 'n' - config A - tristate "A" - depends on N_SYM - - # Has visibility 'm' - config B - tristate "B" - depends on M_SYM - - # Has visibility 'y' - config C - tristate "C" - - # Has no prompt, and hence visibility 'n' - config D - tristate - - Having visibility be tri-valued ensures that e.g. a symbol cannot be - set to "y" by the user if it depends on a symbol with value "m", which - wouldn't be safe. - - You should probably look at get_lower/upper_bound(), - get_assignable_values() and is_modifiable() before using this.""" - return _get_visibility(self) - - def get_referenced_symbols(self, refs_from_enclosing=False): - """Returns the set() of all symbols referenced by this item. For - example, the symbol defined by - - config FOO - bool - prompt "foo" if A && B - default C if D - depends on E - select F if G - - references the symbols A through G. - - refs_from_enclosing (default: False): If True, the symbols referenced - by enclosing menus and ifs will be included in the result.""" - res = [] - - for _, cond_expr in self._orig_prompts: - _expr_syms(cond_expr, res) - for val_expr, cond_expr in self._orig_def_exprs: - _expr_syms(val_expr, res) - _expr_syms(cond_expr, res) - for sym, cond_expr in self._orig_selects: - res.append(sym) - _expr_syms(cond_expr, res) - for sym, cond_expr in self._orig_implies: - res.append(sym) - _expr_syms(cond_expr, res) - for low, high, cond_expr in self._orig_ranges: - res.append(low) - res.append(high) - _expr_syms(cond_expr, res) - - if refs_from_enclosing: - _expr_syms(self._deps_from_containing, res) - - # Remove duplicates and return - return set(res) - - def get_selected_symbols(self): - """Returns the set() of all symbols X for which this symbol has a - 'select X' or 'select X if Y' (regardless of whether Y is satisfied or - not). This is a subset of the symbols returned by - get_referenced_symbols().""" - return {sym for sym, _ in self._orig_selects} - - def get_implied_symbols(self): - """Returns the set() of all symbols X for which this symbol has an - 'imply X' or 'imply X if Y' (regardless of whether Y is satisfied or - not). This is a subset of the symbols returned by - get_referenced_symbols().""" - return {sym for sym, _ in self._orig_implies} - - def set_user_value(self, v): - """Sets the user value of the symbol. + _internal_error("Internal error while creating .config: unknown " + 'type "{}".'.format(self._type)) + + def set_value(self, value): + """ + Sets the user value of the symbol. Equal in effect to assigning the value to the symbol within a .config - file. Use get_lower/upper_bound() or get_assignable_values() to find - the range of currently assignable values for bool and tristate symbols; - setting values outside this range will cause the user value to differ - from the result of Symbol.get_value() (be truncated). Values that are - invalid for the type (such as a_bool.set_user_value("foo")) are - ignored, and a warning is emitted if an attempt is made to assign such - a value. - - For any type of symbol, is_modifiable() can be used to check if a user - value will currently have any effect on the symbol, as determined by - its visibility and range of assignable values. Any value that is valid - for the type (bool, tristate, etc.) will end up being reflected in - get_user_value() though, and might have an effect later if conditions - change. To get rid of the user value, use unset_user_value(). - - Any symbols dependent on the symbol are (recursively) invalidated, so - things will just work with regards to dependencies. - - v: The user value to give to the symbol.""" - self._set_user_value_no_invalidate(v, False) - - if self._name == "MODULES": + file. Use the 'assignable' attribute to check which values can + currently be assigned. Setting values outside 'assignable' will cause + Symbol.user_value to differ from Symbol.value (be truncated down or + up). Values that are invalid for the type (such as "foo" or "m" for a + BOOL) are ignored (and won't be stored in Symbol.user_value). A warning + is printed for attempts to assign invalid values. + + The values of other symbols that depend on this symbol are + automatically recalculated to reflect the new value. + + value: + The user value to give to the symbol. + """ + self._set_value_no_invalidate(value, False) + + if self is self.config.modules: # Changing MODULES has wide-ranging effects - self._config._invalidate_all() - return + self.config._invalidate_all() + else: + self._rec_invalidate() - self._invalidate() - self._invalidate_dependent() - - def unset_user_value(self): - """Resets the user value of the symbol, as if the symbol had never - gotten a user value via Config.load_config() or - Symbol.set_user_value().""" - self._unset_user_value_no_recursive_invalidate() - self._invalidate_dependent() - - def is_modifiable(self): - """Returns True if the value of the symbol could be modified by calling - Symbol.set_user_value(). - - For bools and tristates, this corresponds to the symbol being visible - in the 'make menuconfig' interface and not already being pinned to a - specific value (e.g. because it is selected by another symbol). - - For strings and numbers, this corresponds to just being visible. (See - Symbol.get_visibility().)""" - if self._is_special: - return False - if self._type in (BOOL, TRISTATE): - rev_dep_val = self._config._eval_expr(self._rev_dep) - # A bool selected to "m" gets promoted to "y", pinning it - if rev_dep_val == "m" and self._type == BOOL: - return False - return tri_greater(_get_visibility(self), rev_dep_val) - return _get_visibility(self) != "n" - - def is_defined(self): - """Returns False if the symbol is referred to in the Kconfig but never - actually defined.""" - return self._is_defined - - def is_special(self): - """Returns True if the symbol is one of the special symbols n, m, y, or - UNAME_RELEASE, or gets its value from the environment.""" - return self._is_special - - def is_from_environment(self): - """Returns True if the symbol gets its value from the environment.""" - return self._is_from_env - - def has_ranges(self): - """Returns True if the symbol is of type INT or HEX and has ranges that - limit what values it can take on.""" - return bool(self._ranges) - - def is_choice_symbol(self): - """Returns True if the symbol is in a choice statement and is an actual - choice symbol (see Choice.get_symbols()).""" - return self._is_choice_sym - - def is_choice_selection(self): - """Returns True if the symbol is contained in a choice statement and is - the selected item. Equivalent to - - sym.is_choice_symbol() and sym.get_parent().get_selection() is sym""" - return self._is_choice_sym and self._parent.get_selection() is self - - def is_allnoconfig_y(self): - """Returns True if the symbol has the 'allnoconfig_y' option set.""" - return self._allnoconfig_y + def unset_value(self): + """ + Resets the user value of the symbol, as if the symbol had never gotten + a user value via Config.load_config() or Symbol.set_value(). + """ + self.user_value = None + self._rec_invalidate() def __str__(self): - """Returns a string containing various information about the symbol.""" - return self._config._get_sym_or_choice_str(self) + """ + Returns a string representation of the symbol, matching the Kconfig + format. As a convenience, prompts and help texts are also printed, even + though they really belong to the symbol's menu nodes and not to the + symbol itself. + + The output is designed so that feeding it back to a Kconfig parser + redefines the symbol as is. This also works for symbols defined in + multiple locations, where all the definitions are output. + + An empty string is returned for undefined symbols. + """ + return _sym_choice_str(self) + + def __repr__(self): + """ + Prints some information about the symbol (including its name, value, + and visibility) when it is evaluated. + """ + fields = [ + "symbol " + self.name, + _TYPENAME[self.type], + 'value "{}"'.format(self.value), + "visibility {}".format(self.visibility) + ] + + if self.user_value is not None: + fields.append('user value "{}"'.format(self.user_value)) + + if self.choice is not None: + fields.append("choice symbol") + + if self.is_allnoconfig_y: + fields.append("allnoconfig_y") + + if self is self.config.defconfig_list: + fields.append("is the defconfig_list symbol") + + if self.env_var is not None: + fields.append("from environment variable " + self.env_var) + + if self is self.config.modules: + fields.append("is the modules symbol") + + fields.append("direct deps " + eval_expr(self.direct_deps)) + + fields.append("{} menu node{}" + .format(len(self.nodes), + "" if len(self.nodes) == 1 else "s")) + + return "<{}>".format(", ".join(fields)) # # Private methods # def __init__(self): - """Symbol constructor -- not intended to be called directly by - Kconfiglib clients.""" + """ + Symbol constructor -- not intended to be called directly by Kconfiglib + clients. + """ # These attributes are always set on the instance from outside and # don't need defaults: - # _config - # _name + # config + # name # _already_written self._type = UNKNOWN - self._prompts = [] - self._def_exprs = [] # 'default' properties - self._ranges = [] # 'range' properties (for int and hex) - self._help = None # Help text - self._rev_dep = "n" # Reverse (select-related) dependencies - self._weak_rev_dep = "n" # Weak reverse (imply-related) dependencies - self._parent = None - - self._user_val = None # Value set by user - - # Prompts, default values, ranges, selects, and implies without any - # dependencies from parents propagated to them - self._orig_prompts = [] - self._orig_def_exprs = [] - self._orig_selects = [] - self._orig_implies = [] - self._orig_ranges = [] - - # Dependencies inherited from containing menus and ifs - self._deps_from_containing = None - - # See comment in _parse_properties() - self._menu_dep = None - - # The direct dependencies (inherited + 'depends on', with OR if a - # symbol is defined in multiple locations). This is needed for 'imply' - # support. - self._direct_deps = "n" - - # See Symbol.get_ref/def_locations(). - self._def_locations = [] - self._ref_locations = [] + self.defaults = [] + self.selects = [] + self.implies = [] + self.ranges = [] + self.rev_dep = "n" + self.weak_rev_dep = "n" + + self.nodes = [] + + self.user_value = None + + self.direct_deps = "n" # Populated in Config._build_dep() after parsing. Links the symbol to # the symbols that immediately depend on it (in a caching/invalidation - # sense). The total set of dependent symbols for the symbol (the - # transitive closure) is calculated on an as-needed basis in - # _get_dependent(). + # sense). The total set of dependent symbols for the symbol is + # calculated as needed in _get_dependent(). self._direct_dependents = set() # Cached values # Caches the calculated value self._cached_val = None - # Caches the visibility, which acts as an upper bound on the value - self._cached_visibility = None + # Caches the visibility + self._cached_vis = None # Caches the total list of dependent symbols. Calculated in # _get_dependent(). self._cached_deps = None + # Caches the 'assignable' attribute + self._cached_assignable = None # Flags - # Does the symbol have an entry in the Kconfig file? - self._is_defined = False - # Should the symbol get an entry in .config? + self.env_var = None + + self.choice = None + self.is_allnoconfig_y = False + + # Should the symbol get an entry in .config? Calculated along with the + # value. self._write_to_conf = False - # This is set to True for "actual" choice symbols; see - # Choice._determine_actual_symbols(). - self._is_choice_sym = False - # Does the symbol get its value in some special way, e.g. from the - # environment or by being one of the special symbols n, m, and y? If - # so, the value is stored in self._cached_val, which is never - # invalidated. - self._is_special = False - # Does the symbol get its value from the environment? - self._is_from_env = False - # Does the symbol have the 'allnoconfig_y' option set? - self._allnoconfig_y = False - def _invalidate(self): - if self._is_special: - # Special symbols never change value and keep their value in - # _cached_val - return + def _get_assignable(self): + """ + Worker function for the 'assignable' attribute. + """ - if self._is_choice_sym: - self._parent._invalidate() + if self._type not in (BOOL, TRISTATE): + return "" - self._cached_val = None - self._cached_visibility = None + vis = self.visibility - def _invalidate_dependent(self): - for sym in self._get_dependent(): - sym._invalidate() + if vis == "n": + return "" - def _set_user_value_no_invalidate(self, v, suppress_load_warnings): - """Like set_user_value(), but does not invalidate any symbols. + rev_dep_val = eval_expr(self.rev_dep) - suppress_load_warnings: some warnings are annoying when loading a - .config that can be helpful when manually invoking set_user_value(). - This flag is set to True to suppress such warnings. + if vis == "y": + if rev_dep_val == "n": + if self.type == BOOL or eval_expr(self.weak_rev_dep) == "y": + return "ny" + return "nmy" - Perhaps this could be made optional for load_config() instead.""" + if rev_dep_val == "y": + return "y" - if self._is_special: - if self._is_from_env: - self._config._warn('attempt to assign the value "{}" to the ' - 'symbol {}, which gets its value from the ' - 'environment. Assignment ignored.' - .format(v, self._name)) - else: - self._config._warn('attempt to assign the value "{}" to the ' - 'special symbol {}. Assignment ignored.' - .format(v, self._name)) - return + # rev_dep_val == "m" - if not self._is_defined: - filename, linenr = self._ref_locations[0] - self._config._warn_undef_assign( - 'attempt to assign the value "{}" to {}, which is referenced ' - "at {}:{} but never defined. Assignment ignored." - .format(v, self._name, filename, linenr)) - return + if self.type == BOOL or eval_expr(self.weak_rev_dep) == "y": + return "y" + return "my" - # Check if the value is valid for our type - if not ((self._type == BOOL and v in ("n", "y") ) or - (self._type == TRISTATE and v in ("n", "m", "y")) or - (self._type == STRING ) or - (self._type == INT and _is_base_n(v, 10) ) or - (self._type == HEX and _is_base_n(v, 16) )): - self._config._warn('the value "{}" is invalid for {}, which has ' - "type {}. Assignment ignored." - .format(v, self._name, _TYPENAME[self._type])) - return + # vis == "m" - if not self._prompts and not suppress_load_warnings: - self._config._warn('assigning "{}" to the symbol {} which lacks ' - 'prompts and thus has visibility "n". The ' - 'assignment will have no effect.' - .format(v, self._name)) + if rev_dep_val == "n": + return "m" if eval_expr(self.weak_rev_dep) != "y" else "y" - self._user_val = v + if rev_dep_val == "y": + return "y" - if self._is_choice_sym and self._type in (BOOL, TRISTATE): - choice = self._parent - if v == "y": - choice._user_val = self - choice._user_mode = "y" - elif v == "m": - choice._user_val = None - choice._user_mode = "m" + # vis == "m", rev_dep == "m" (rare) - def _unset_user_value_no_recursive_invalidate(self): - self._invalidate() - self._user_val = None + return "m" - if self._is_choice_sym: - self._parent._unset_user_value() + def _set_value_no_invalidate(self, value, suppress_prompt_warning): + """ + Like set_value(), but does not invalidate any symbols. - def _add_config_strings(self, add_fn): - if self._already_written: + suppress_prompt_warning: + The warning about assigning a value to a promptless symbol gets + spammy for Linux defconfigs, so turn it off when loading .configs. + It's still helpful when manually invoking set_value(). + """ + + # Check if the value is valid for our type + if not ((self._type == BOOL and value in ("n", "y") ) or + (self._type == TRISTATE and value in ("n", "m", "y")) or + (self._type == STRING ) or + (self._type == INT and _is_base_n(value, 10) ) or + (self._type == HEX and _is_base_n(value, 16) )): + self.config._warn('the value "{}" is invalid for {}, which has ' + "type {}. Assignment ignored." + .format(value, self.name, _TYPENAME[self._type])) return - self._already_written = True + if not self.nodes: + self.config._warn_undef_assign( + 'assigning the value "{}" to the undefined symbol {} will ' + "have no effect".format(value, self.name)) - # Note: _write_to_conf is determined in get_value() - val = self.get_value() - if not self._write_to_conf: - return + if not suppress_prompt_warning: + for node in self.nodes: + if node.prompt is not None: + break + else: + self.config._warn('assigning the value "{}" to the ' + "promptless symbol {} will have no effect" + .format(value, self.name)) - if self._type in (BOOL, TRISTATE): - add_fn("# {}{} is not set\n".format(self._config._config_prefix, - self._name) - if val == "n" else - "{}{}={}\n".format(self._config._config_prefix, self._name, - val)) + self.user_value = value - elif self._type in (INT, HEX): - add_fn("{}{}={}\n".format(self._config._config_prefix, self._name, - val)) + if self.choice is not None and self._type in (BOOL, TRISTATE): + if value == "y": + self.choice.user_selection = self + self.choice.user_value = "y" + elif value == "m": + self.choice.user_value = "m" - elif self._type == STRING: - # Escape \ and " - add_fn('{}{}="{}"\n' - .format(self._config._config_prefix, self._name, - val.replace("\\", "\\\\").replace('"', '\\"'))) + def _invalidate(self): + """ + Marks the symbol as needing to be recalculated. + """ + self._cached_val = self._cached_vis = self._cached_assignable = None - else: - _internal_error("Internal error while creating .config: unknown " - 'type "{}".'.format(self._type)) + def _rec_invalidate(self): + """ + Invalidates the symbol and all symbols and choices that (possibly + indirectly) depend on it + """ + self._invalidate() + + for item in self._get_dependent(): + item._invalidate() def _get_dependent(self): - """Returns the set of symbols that should be invalidated if the value - of the symbol changes, because they might be affected by the change. - Note that this is an internal API -- it's probably of limited - usefulness to clients.""" + """ + Returns the set of symbols that should be invalidated if the value of + the symbol changes, because they might be affected by the change. Note + that this is an internal API and probably of limited usefulness to + clients. + """ if self._cached_deps is not None: return self._cached_deps @@ -2727,554 +2281,506 @@ class Symbol(Item): {sym for dep in self._direct_dependents for sym in dep._get_dependent()} - if self._is_choice_sym: + if self.choice is not None: + # Choices depend on their choice symbols + res.add(self.choice) + # Choice symbols also depend (recursively) on their siblings. The # siblings are not included in _direct_dependents to avoid # dependency loops. - for sibling in self._parent._actual_symbols: + for sibling in self.choice.syms: if sibling is not self: res.add(sibling) - res |= sibling._direct_dependents - for s in sibling._direct_dependents: - res |= s._get_dependent() - - self._cached_deps = res - return res - - def _has_auto_menu_dep_on(self, on): - """See Choice._determine_actual_symbols().""" - if not isinstance(self._parent, Choice): - _internal_error("Attempt to determine auto menu dependency for " - "symbol ouside of choice.") - - if not self._prompts: - # If we have no prompt, use the menu dependencies instead (what was - # specified with 'depends on') - return self._menu_dep is not None and \ - self._config._expr_depends_on(self._menu_dep, on) - - for _, cond_expr in self._prompts: - if self._config._expr_depends_on(cond_expr, on): - return True - - return False + # Less readable version of the following: + # + # res |= sibling._direct_dependents + # for s in sibling._direct_dependents: + # res |= s._get_dependent() + res |= sibling._direct_dependents | \ + {sym for dep in sibling._direct_dependents + for sym in dep._get_dependent()} -class Menu(Item): + # The tuple conversion sped up allnoconfig_simpler.py by 10% + self._cached_deps = tuple(res) + return self._cached_deps - """Represents a menu statement.""" +class Choice(object): + """ + Represents a choice statement: + + choice + ... + + The following attributes are available on Choice instances. They should be + viewed as read-only, and some are implemented through @property magic (but + are still efficient to access due to internal caching). + + name: + The name of the choice, e.g. "FOO" for 'choice FOO', or None if the + Choice has no name. I can't remember ever seeing named choices in + practice, but the C tools support them too. + + type: + The type of the choice. One of BOOL, TRISTATE, UNKNOWN. UNKNOWN is for + choices defined without a type where none of the contained symbols have a + type either (otherwise the choice inherits the type of the first symbol + defined with a type). + + When running without modules (CONFIG_MODULES=n), TRISTATE choices + magically change type to BOOL. This matches the C tools, and makes sense + for menuconfig-like functionality. (Check the implementation of the + property if you need to get the original type.) + + value: + The tristate value (mode) of the choice. A choice can be in one of three + modes: + + "n" - The choice is not visible and no symbols can be selected. + + "m" - Any number of symbols can be set to "m". The rest will be "n". + + "y" - One symbol will be "y" while the rest are "n". + + Only tristate choices can be in "m" mode, and the visibility of the + choice is an upper bound on the mode. + + The mode changes automatically when a value is assigned to a symbol + within the choice (this makes .config loading "just work"), and can also + be changed via Choice.set_value(). + + See the implementation note at the end for one reason why it makes sense + to call this 'value' rather than e.g. 'mode'. It also makes the Choice + and Symbol interfaces consistent. + + assignable: + See the symbol class documentation. Gives the assignable values (modes). + + visibility: + See the Symbol class documentation. Acts on the value (mode). + + selection: + The currently selected symbol. None if the Choice is not in "y" mode or + has no selected symbol (due to unsatisfied dependencies on choice + symbols). + + default_selection: + The symbol that would be selected by default, had the user not selected + any symbol. Can be None for the same reasons as 'selected'. + + user_value: + The value (mode) selected by the user (by assigning some choice symbol or + calling Choice.set_value()). This does not necessarily match Choice.value + for the same reasons that Symbol.user_value might not match Symbol.value. + + user_selection: + The symbol selected by the user (by setting it to "y"). Ignored if the + choice is not in "y" mode, but still remembered so that the choice "snaps + back" to the user selection if the mode is changed back to "y". + + syms: + List of symbols contained in the choice. + + Gotcha: If a symbol depends on a previous symbol within a choice so that + an implicit menu is created, it won't be a choice symbol, and won't be + included in 'syms'. There are real-world examples of this. + + nodes: + A list of MenuNode's for this symbol. In practice, the list will probably + always contain a single MenuNode, but it is possible to define a choice + in multiple locations by giving it a name, which adds more nodes. + + defaults: + List of (symbol, cond) tuples for the choices 'defaults's. For example, + 'default A if B && C' is represented as (A, (AND, B, C)). If there is no + condition, 'cond' is None. + + Note that 'depends on' and parent dependencies are propagated to + 'default' conditions. + + is_optional: + True if the choice has the 'optional' flag set on it. + + Implementation note: The C tools internally represent choices as a type of + symbol, with special-casing in many code paths, which is why there is a lot + of similarity to Symbol above. The value (mode) is really just a normal + symbol value, and an implicit reverse dependency forces its lower bound to + 'm' for non-optional choices. Kconfiglib uses a separate Choice class only + because it makes the code and interface less confusing (especially in a + user-facing interface). + """ + + __slots__ = ( + "_cached_assignable", + "_cached_selection", + "_cached_vis", + "_type", + "config", + "defaults", + "is_optional", + "name", + "nodes", + "syms", + "user_selection", + "user_value", + ) # # Public interface # - def get_config(self): - """Return the Config instance this menu is from.""" - return self._config - - def get_title(self): - """Returns the title text of the menu.""" - return self._title - - def get_parent(self): - """Returns the menu or choice statement that contains the menu, or - None if the menu is at the top level. Note that if statements are - treated as syntactic sugar and do not have an explicit class - representation.""" - return self._parent - - def get_location(self): - """Returns the location of the menu as a (filename, linenr) tuple, - where filename is a string and linenr an int.""" - return (self._filename, self._linenr) - - def get_items(self, recursive=False): - """Returns a list containing the items (symbols, menus, choice - statements and comments) in in the menu, in the same order that the - items appear within the menu. - - recursive (default: False): True if items contained in items within the - menu should be included recursively (preorder).""" - - if not recursive: - return self._block - - res = [] - for item in self._block: - res.append(item) - if isinstance(item, Menu): - res.extend(item.get_items(True)) - elif isinstance(item, Choice): - res.extend(item.get_items()) - return res - - def get_symbols(self, recursive=False): - """Returns a list containing the symbols in the menu, in the same order - that they appear within the menu. - - recursive (default: False): True if symbols contained in items within - the menu should be included recursively.""" - - return [item for item in self.get_items(recursive) if - isinstance(item, Symbol)] - - def get_visibility(self): - """Returns the visibility of the menu. This also affects the visibility - of subitems. See also Symbol.get_visibility().""" - return self._config._eval_expr(self._menu_dep) - - def get_visible_if_visibility(self): - """Returns the visibility the menu gets from its 'visible if' - condition. "y" if the menu has no 'visible if' condition.""" - return self._config._eval_expr(self._visible_if_expr) - - def get_referenced_symbols(self, refs_from_enclosing=False): - """See Symbol.get_referenced_symbols().""" - res = [] - - _expr_syms(self._visible_if_expr, res) - _expr_syms(self._orig_deps - if not refs_from_enclosing else - self._menu_dep, - res) - - # Remove duplicates and return - return set(res) - - def __str__(self): - """Returns a string containing various information about the menu.""" - depends_on_str = self._config._expr_val_str(self._orig_deps, - "(no dependencies)") - visible_if_str = self._config._expr_val_str(self._visible_if_expr, - "(no dependencies)") - - additional_deps_str = " " + \ - self._config._expr_val_str(self._deps_from_containing, - "(no additional dependencies)") - - return _lines("Menu", - "Title : " + self._title, - "'depends on' dependencies : " + depends_on_str, - "'visible if' dependencies : " + visible_if_str, - "Additional dependencies from enclosing menus and ifs:", - additional_deps_str, - "Location: {}:{}".format(self._filename, self._linenr)) - - # - # Private methods - # - - def __init__(self): - """Menu constructor -- not intended to be called directly by - Kconfiglib clients.""" - - # These attributes are always set on the instance from outside and - # don't need defaults: - # _config - # _parent - # _filename - # _linenr - # _title - # _deps_from_containing - # _menu_dep - - # Dependencies specified with 'visible_if' - self._visible_if_expr = None - - # Dependency expression without dependencies from enclosing menus and - # ifs propagated - self._orig_deps = None - - # Contained items - self._block = [] - - def _add_config_strings(self, add_fn): - if self._config._eval_expr(self._menu_dep) != "n" and \ - self._config._eval_expr(self._visible_if_expr) != "n": - add_fn("\n#\n# {}\n#\n".format(self._title)) - - for item in self._block: - item._add_config_strings(add_fn) - -class Choice(Item): - - """Represents a choice statement. A choice can be in one of three modes: - - "n" - The choice is not visible and no symbols can be selected. - - "m" - Any number of symbols can be set to "m". The rest will be "n". This - is safe since potentially conflicting options don't actually get - compiled into the kernel simultaneously with "m". - - "y" - One symbol will be "y" while the rest are "n". + @property + def type(self): + """Returns the type of the choice. See Symbol.type.""" + if self._type == TRISTATE and self.config.modules.value == "n": + return BOOL + return self._type - Only tristate choices can be in "m" mode, and the visibility of the choice - is an upper bound on the mode, so that e.g. a choice that depends on a - symbol with value "m" will be in "m" mode. + @property + def value(self): + """ + See the class documentation. + """ + if self.user_value is not None: + val = _eval_min(self.user_value, self.visibility) + else: + val = "n" - The mode changes automatically when a value is assigned to a symbol within - the choice. + if val == "n" and not self.is_optional: + val = "m" - See Symbol.get_visibility() too.""" + # Promote "m" to "y" for boolean choices + return "y" if val == "m" and self.type == BOOL else val - # - # Public interface - # + @property + def assignable(self): + """ + See the class documentation. + """ + if self._cached_assignable is not None: + return self._cached_assignable - def get_config(self): - """Returns the Config instance this choice is from.""" - return self._config + self._cached_assignable = self._get_assignable() + return self._cached_assignable - def get_name(self): - """For named choices, returns the name. Returns None for unnamed - choices. No named choices appear anywhere in the kernel Kconfig files - as of Linux 3.7.0-rc8.""" - return self._name + @property + def visibility(self): + """ + See the class documentation. + """ + if self._cached_vis is not None: + return self._cached_vis - def get_type(self): - """Returns the type of the choice. See Symbol.get_type().""" - return self._type + self._cached_vis = _get_visibility(self) + return self._cached_vis - def get_prompts(self): - """Returns a list of prompts defined for the choice, in the order they - appear in the configuration files. Returns the empty list for choices - with no prompt. - - This list will have a single entry for the vast majority of choices - having prompts, but having multiple prompts for a single choice is - possible through having multiple 'choice' entries for it (though I'm - not sure if that ever happens in practice).""" - return [prompt for prompt, _ in self._orig_prompts] - - def get_help(self): - """Returns the help text of the choice, or None if the choice has no - help text.""" - return self._help - - def get_parent(self): - """Returns the menu or choice statement that contains the choice, or - None if the choice is at the top level. Note that if statements are - treated as syntactic sugar and do not have an explicit class - representation.""" - return self._parent - - def get_def_locations(self): - """Returns a list of (filename, linenr) tuples, where filename (string) - and linenr (int) represent a location where the choice is defined. For - the vast majority of choices (all of them as of Linux 3.7.0-rc8) this - list will only contain one element, but its possible for named choices - to be defined in multiple locations.""" - return self._def_locations - - def get_selection(self): - """Returns the symbol selected (either by the user or through - defaults), or None if either no symbol is selected or the mode is not - "y".""" - if self._cached_selection is not None: - if self._cached_selection == _NO_SELECTION: - return None + @property + def selection(self): + """ + See the class documentation. + """ + if self._cached_selection is not _NO_CACHED_SELECTION: return self._cached_selection - if self.get_mode() != "y": - return self._cache_ret(None) + if self.value != "y": + self._cached_selection = None + return None # User choice available? - if self._user_val is not None and \ - _get_visibility(self._user_val) == "y": - return self._cache_ret(self._user_val) - - if self._optional: - return self._cache_ret(None) + if self.user_selection is not None and \ + self.user_selection.visibility == "y": + self._cached_selection = self.user_selection + return self.user_selection - return self._cache_ret(self.get_selection_from_defaults()) + # Look at defaults - def get_selection_from_defaults(self): - """Like Choice.get_selection(), but acts as if no symbol has been - selected by the user and no 'optional' flag is in effect.""" + self._cached_selection = self.default_selection + return self._cached_selection - # Does any 'default SYM [if <cond>]' property apply? - for sym, cond_expr in self._def_exprs: - if (self._config._eval_expr(cond_expr) != "n" and + @property + def default_selection(self): + """ + See the class documentation. + """ + for sym, cond_expr in self.defaults: + if (eval_expr(cond_expr) != "n" and # Must be visible too - _get_visibility(sym) != "n"): + sym.visibility != "n"): return sym - # Otherwise, pick the first visible symbol - for sym in self._actual_symbols: - if _get_visibility(sym) != "n": + # Otherwise, pick the first visible symbol, if any + for sym in self.syms: + if sym.visibility != "n": return sym # Couldn't find a default return None - def get_user_selection(self): - """If the choice is in "y" mode and has a user-selected symbol, returns - that symbol. Otherwise, returns None.""" - return self._user_val - - def get_items(self): - """Gets all items contained in the choice in the same order as within - the configuration ("items" instead of "symbols" since choices and - comments might appear within choices. This only happens in one place as - of Linux 3.7.0-rc8, in drivers/usb/gadget/Kconfig).""" - return self._block - - def get_symbols(self): - """Returns a list containing the choice's symbols. - - A quirk (perhaps a bug) of Kconfig is that you can put items within a - choice that will not be considered members of the choice insofar as - selection is concerned. This happens for example if one symbol within a - choice 'depends on' the symbol preceding it, or if you put non-symbol - items within choices. - - As of Linux 3.7.0-rc8, this seems to be used intentionally in one - place: drivers/usb/gadget/Kconfig. - - This function returns the "proper" symbols of the choice in the order - they appear in the choice, excluding such items. If you want all items - in the choice, use get_items().""" - return self._actual_symbols - - def get_referenced_symbols(self, refs_from_enclosing=False): - """See Symbol.get_referenced_symbols().""" - res = [] - - for _, cond_expr in self._orig_prompts: - _expr_syms(cond_expr, res) - for val_expr, cond_expr in self._orig_def_exprs: - _expr_syms(val_expr, res) - _expr_syms(cond_expr, res) - - if refs_from_enclosing: - _expr_syms(self._deps_from_containing, res) - - # Remove duplicates and return - return set(res) - - def get_visibility(self): - """Returns the visibility of the choice statement: one of "n", "m" or - "y". This acts as an upper limit on the mode of the choice (though bool - choices can only have the mode "y"). See the class documentation for an - explanation of modes.""" - return _get_visibility(self) - - def get_mode(self): - """Returns the mode of the choice. See the class documentation for - an explanation of modes.""" - minimum_mode = "n" if self._optional else "m" - mode = self._user_mode if self._user_mode is not None else minimum_mode - mode = self._config._eval_min(mode, _get_visibility(self)) + def set_value(self, value): + """ + Sets the user value (mode) of the choice. Like for Symbol.set_value(), + the visibility might truncate the value. Choices without the 'optional' + attribute (is_optional) can never be in "n" mode, but "n" is still + accepted (and ignored) since it's not a malformed value. + """ + if not ((self._type == BOOL and value in ("n", "y") ) or + (self._type == TRISTATE and value in ("n", "m", "y"))): + self.config._warn('the value "{}" is invalid for the choice, ' + "which has type {}. Assignment ignored" + .format(value, _TYPENAME[self._type])) - # Promote "m" to "y" for boolean choices - if mode == "m" and self._type == BOOL: - return "y" + self.user_value = value - return mode + if self.syms: + # Hackish way to invalidate the choice and all the choice symbols + self.syms[0]._rec_invalidate() - def is_optional(self): - """Returns True if the choice has the 'optional' flag set (and so will - default to "n" mode).""" - return self._optional + def unset_value(self): + """ + Resets the user value (mode) and user selection of the Choice, as if + the user had never touched the mode or any of the choice symbols. + """ + self.user_value = self.user_selection = None + if self.syms: + # Hackish way to invalidate the choice and all the choice symbols + self.syms[0]._rec_invalidate() def __str__(self): - """Returns a string containing various information about the choice - statement.""" - return self._config._get_sym_or_choice_str(self) + """ + Returns a string containing various information about the choice + statement. + """ + return _sym_choice_str(self) + + def __repr__(self): + fields = [ + "choice" if self.name is None else "choice " + self.name, + _TYPENAME[self.type], + "mode " + self.value, + "visibility " + self.visibility] + + if self.is_optional: + fields.append("optional") + + if self.selection is not None: + fields.append("{} selected".format(self.selection.name)) + + fields.append("{} menu node{}" + .format(len(self.nodes), + "" if len(self.nodes) == 1 else "s")) + + return "<{}>".format(", ".join(fields)) + # # Private methods # def __init__(self): - """Choice constructor -- not intended to be called directly by - Kconfiglib clients.""" + """ + Choice constructor -- not intended to be called directly by Kconfiglib + clients. + """ # These attributes are always set on the instance from outside and # don't need defaults: - # _config - # _parent - # _deps_from_containing - # _actual_symbols (set in _determine_actual_symbols()) + # config - self._name = None # Yes, choices can be named + self.name = None self._type = UNKNOWN - self._prompts = [] - self._def_exprs = [] # 'default' properties - self._help = None # Help text + self.syms = [] + self.defaults = [] - self._user_val = None - self._user_mode = None + self.nodes = [] + + self.user_selection = None + self.user_value = None # The prompts and default values without any dependencies from # enclosing menus and ifs propagated - self._orig_prompts = [] - self._orig_def_exprs = [] - - # See Choice.get_def_locations() - self._def_locations = [] + self.defaults = [] # Cached values - self._cached_selection = None - self._cached_visibility = None - - self._optional = False - - # Contained items - self._block = [] - - def _determine_actual_symbols(self): - """If a symbol's visibility depends on the preceding symbol within a - choice, it is no longer viewed as a choice item. (This is quite - possibly a bug, but some things consciously use it... ugh. It stems - from automatic submenu creation.) In addition, it's possible to have - choices and comments within choices, and those shouldn't be considered - choice items either. Only drivers/usb/gadget/Kconfig seems to depend on - any of this. This method computes the "actual" items in the choice and - sets the _is_choice_sym flag on them (retrieved via - is_choice_symbol()). - - Don't let this scare you: an earlier version simply checked for a - sequence of symbols where all symbols after the first appeared in the - 'depends on' expression of the first, and that worked fine. The added - complexity is to be future-proof in the event that - drivers/usb/gadget/Kconfig turns even more sinister. It might very well - be overkilling things (especially if that file is refactored ;).""" - - self._actual_symbols = [] - - # Items might depend on each other in a tree structure, so we need a - # stack to keep track of the current tentative parent - stack = [] - - for item in self._block: - if not isinstance(item, Symbol): - stack = [] - continue + self._cached_selection = _NO_CACHED_SELECTION + self._cached_vis = None + self._cached_assignable = None - while stack: - if item._has_auto_menu_dep_on(stack[-1]): - # The item should not be viewed as a choice item, so don't - # set item._is_choice_sym - stack.append(item) - break - else: - stack.pop() - else: - item._is_choice_sym = True - self._actual_symbols.append(item) - stack.append(item) - - def _cache_ret(self, selection): - # As None is used to indicate the lack of a cached value we can't use - # that to cache the fact that the choice has no selection. Instead, we - # use the symbolic constant _NO_SELECTION. - if selection is None: - self._cached_selection = _NO_SELECTION - else: - self._cached_selection = selection + self.is_optional = False - return selection + def _get_assignable(self): + """ + Worker function for the 'assignable' attribute. + """ - def _invalidate(self): - self._cached_selection = None - self._cached_visibility = None + vis = self.visibility - def _unset_user_value(self): - self._invalidate() - self._user_val = None - self._user_mode = None + if vis == "n": + return "" - def _add_config_strings(self, add_fn): - for item in self._block: - item._add_config_strings(add_fn) + if vis == "y": + if not self.is_optional: + return "y" if self.type == BOOL else "my" + return "y" -class Comment(Item): + # vis == "m" - """Represents a comment statement.""" + return "nm" if self.is_optional else "m" - # - # Public interface - # + def _invalidate(self): + self._cached_selection = _NO_CACHED_SELECTION + self._cached_vis = self._cached_assignable = None + +class MenuNode(object): + """ + Represents a menu node in the configuration. This corresponds to an entry + in e.g. the 'make menuconfig' interface, though non-visible, + non-user-assignable symbols, choices, menus, and comments also get menu + nodes. If a symbol or choice is defined in multiple locations, it gets one + menu node for each location. + + The top-level menu node, corresponding to the implicit top-level menu, is + available in Config.top_menu. + + For symbols and choices, the menu nodes are available in the 'nodes' + attribute. Menus and comments are represented as plain menu nodes, with + their text stored in the prompt attribute (prompt[0]). This mirrors the C + implementation. + + The following attributes are available on MenuNode instances. They should + be viewed as read-only. + + item: + Either a Symbol, a Choice, or one of the constants MENU and COMMENT. + Menus and comments are represented as plain menu nodes. Ifs are + collapsed and do not appear in the final menu tree (matching the C + implementation). + + next: + The following menu node in the menu tree. None if there is no following + node. + + list: + The first child menu node in the menu tree. None if there are no + children. + + Choices and menus naturally have children, but Symbols can have + children too because of menus created automatically from dependencies + (see kconfig-language.txt). + + parent: + The parent menu node. None if there is no parent. + + prompt: + A (string, cond) tuple with the prompt for the menu node and its + condition. None if there is no prompt. Prompts are always stored in the + menu node rather than the Symbol or Choice. For menus and comments, the + prompt holds the text. + + help: + The help text for the menu node. None if there is no help text. Always + stored in the node rather than the Symbol or Choice. It is possible to + have a separate help at each location if a symbol is defined in + multiple locations. + + dep: + The 'depends on' dependencies for the menu node. None if there are no + dependencies. Parent dependencies are propagated to this attribute, and + this attribute is then in turn propagated to the properties of symbols + and choices. + + If a symbol is defined in multiple locations, only the properties + defined at each location get the corresponding MenuNode.dep propagated + to them. + + visibility: + The 'visible if' dependencies for the menu node (which must represent a + menu). None if there are no 'visible if' dependencies. 'visible if' + dependencies are recursively propagated to the prompts of symbols and + choices within the menu. + + is_menuconfig: + True if the symbol for the menu node (it must be a symbol) was defined + with 'menuconfig' rather than 'config' (at this location). This is a + hint on how to display the menu entry. It's ignored by Kconfiglib + itself. + + config: + The Config the menu node is from. + + filename/linenr: + The location where the menu node appears. + """ + + __slots__ = ( + "config", + "dep", + "filename", + "help", + "is_menuconfig", + "item", + "linenr", + "list", + "next", + "parent", + "prompt", + "visibility", + ) + + def __repr__(self): + fields = [] + + if isinstance(self.item, Symbol): + fields.append("menu node for symbol " + self.item.name) + elif isinstance(self.item, Choice): + s = "menu node for choice" + if self.item.name is not None: + s += " " + self.item.name + fields.append(s) + elif self.item == MENU: + fields.append("menu node for menu") + elif self.item == COMMENT: + fields.append("menu node for comment") + elif self.item is None: + fields.append("menu node for if (should not appear in the final " + " tree)") + else: + raise InternalError("unable to determine type in " + "MenuNode.__repr__()") - def get_config(self): - """Returns the Config instance this comment is from.""" - return self._config + fields.append("{}:{}".format(self.filename, self.linenr)) - def get_text(self): - """Returns the text of the comment.""" - return self._text + if self.prompt is not None: + fields.append('prompt "{}" (visibility {})' + .format(self.prompt[0], eval_expr(self.prompt[1]))) - def get_parent(self): - """Returns the menu or choice statement that contains the comment, or - None if the comment is at the top level. Note that if statements are - treated as syntactic sugar and do not have an explicit class - representation.""" - return self._parent + if isinstance(self.item, Symbol) and self.is_menuconfig: + fields.append("is menuconfig") - def get_location(self): - """Returns the location of the comment as a (filename, linenr) tuple, - where filename is a string and linenr an int.""" - return (self._filename, self._linenr) + fields.append("deps " + eval_expr(self.dep)) - def get_visibility(self): - """Returns the visibility of the comment. See also - Symbol.get_visibility().""" - return self._config._eval_expr(self._menu_dep) + if self.item == MENU: + fields.append("'visible if' deps " + eval_expr(self.visibility)) - def get_referenced_symbols(self, refs_from_enclosing=False): - """See Symbol.get_referenced_symbols().""" - res = [] + if isinstance(self.item, (Symbol, Choice)) and self.help is not None: + fields.append("has help") - _expr_syms(self._orig_deps - if not refs_from_enclosing else - self._menu_dep, - res) + if self.list is not None: + fields.append("has child") - # Remove duplicates and return - return set(res) + if self.next is not None: + fields.append("has next") - def __str__(self): - """Returns a string containing various information about the - comment.""" - dep_str = self._config._expr_val_str(self._orig_deps, - "(no dependencies)") - - additional_deps_str = " " + \ - self._config._expr_val_str(self._deps_from_containing, - "(no additional dependencies)") - - return _lines("Comment", - "Text: " + self._text, - "Dependencies: " + dep_str, - "Additional dependencies from enclosing menus and ifs:", - additional_deps_str, - "Location: {}:{}".format(self._filename, self._linenr)) - - # - # Private methods - # + return "<{}>".format(", ".join(fields)) - # These attributes are always set on the instance from outside and don't - # need defaults: - # _config - # _parent - # _filename - # _linenr - # _text - # _deps_from_containing - # _menu_dep - # _orig_deps - - def _add_config_strings(self, add_fn): - if self._config._eval_expr(self._menu_dep) != "n": - add_fn("\n#\n# {}\n#\n".format(self._text)) - -class Kconfig_Syntax_Error(Exception): - """Exception raised for syntax errors.""" +class KconfigSyntaxError(Exception): + """ + Exception raised for syntax errors. + """ pass -class Internal_Error(Exception): - """Exception raised for internal errors.""" +class InternalError(Exception): + """ + Exception raised for internal errors. + """ pass # @@ -3282,83 +2788,184 @@ class Internal_Error(Exception): # def tri_less(v1, v2): - """Returns True if the tristate v1 is less than the tristate v2, where "n", - "m" and "y" are ordered from lowest to highest.""" + """ + Returns True if the tristate v1 is less than the tristate v2, where "n", + "m" and "y" are ordered from lowest to highest. + """ return _TRI_TO_INT[v1] < _TRI_TO_INT[v2] def tri_less_eq(v1, v2): - """Returns True if the tristate v1 is less than or equal to the tristate - v2, where "n", "m" and "y" are ordered from lowest to highest.""" + """ + Returns True if the tristate v1 is less than or equal to the tristate v2, + where "n", "m" and "y" are ordered from lowest to highest. + """ return _TRI_TO_INT[v1] <= _TRI_TO_INT[v2] def tri_greater(v1, v2): - """Returns True if the tristate v1 is greater than the tristate v2, where - "n", "m" and "y" are ordered from lowest to highest.""" + """ + Returns True if the tristate v1 is greater than the tristate v2, where "n", + "m" and "y" are ordered from lowest to highest. + """ return _TRI_TO_INT[v1] > _TRI_TO_INT[v2] def tri_greater_eq(v1, v2): - """Returns True if the tristate v1 is greater than or equal to the tristate - v2, where "n", "m" and "y" are ordered from lowest to highest.""" + """ + Returns True if the tristate v1 is greater than or equal to the tristate + v2, where "n", "m" and "y" are ordered from lowest to highest. + """ return _TRI_TO_INT[v1] >= _TRI_TO_INT[v2] +# Expression evaluation + +def eval_expr(expr): + """ + Evaluates an expression to "n", "m", or "y". Returns "y" for None, which + makes sense as None usually indicates a missing condition. + """ + return "y" if expr is None else _eval_expr_rec(expr) + +def _eval_expr_rec(expr): + if isinstance(expr, Symbol): + # Non-bool/tristate symbols are always "n" in a tristate sense, + # regardless of their value + return expr.value if expr._type in (BOOL, TRISTATE) else "n" + + if isinstance(expr, str): + return expr if expr in ("m", "y") else "n" + + if expr[0] == _AND: + ev1 = _eval_expr_rec(expr[1]) + if ev1 == "n": + # No need to look at expr[2] + return "n" + ev2 = _eval_expr_rec(expr[2]) + return ev2 if ev1 == "y" else \ + "m" if ev2 != "n" else \ + "n" + + if expr[0] == _OR: + ev1 = _eval_expr_rec(expr[1]) + if ev1 == "y": + # No need to look at expr[2] + return "y" + ev2 = _eval_expr_rec(expr[2]) + return ev2 if ev1 == "n" else \ + "y" if ev2 == "y" else \ + "m" + + if expr[0] == _NOT: + ev = _eval_expr_rec(expr[1]) + return "n" if ev == "y" else \ + "y" if ev == "n" else \ + "m" + + if expr[0] in _RELATIONS: + # Implements <, <=, >, >= comparisons as well. These were added to + # kconfig in 31847b67 (kconfig: allow use of relations other than + # (in)equality). + + # This mirrors the C tools pretty closely. Perhaps there's a more + # pythonic way to structure this. + + oper, op1, op2 = expr + op1_type, op1_str = _type_and_val(op1) + op2_type, op2_str = _type_and_val(op2) + + # If both operands are strings... + if op1_type == STRING and op2_type == STRING: + # ...then compare them lexicographically + comp = _strcmp(op1_str, op2_str) + else: + # Otherwise, try to compare them as numbers + try: + comp = int(op1_str, _TYPE_TO_BASE[op1_type]) - \ + int(op2_str, _TYPE_TO_BASE[op2_type]) + except ValueError: + # They're not both valid numbers. If the comparison is + # anything but = or !=, return 'n'. Otherwise, reuse + # _strcmp() to check for (in)equality. + if oper not in (_EQUAL, _UNEQUAL): + return "n" + comp = _strcmp(op1_str, op2_str) + + if oper == _EQUAL: res = comp == 0 + elif oper == _UNEQUAL: res = comp != 0 + elif oper == _LESS: res = comp < 0 + elif oper == _LESS_EQUAL: res = comp <= 0 + elif oper == _GREATER: res = comp > 0 + elif oper == _GREATER_EQUAL: res = comp >= 0 + + return "y" if res else "n" + + _internal_error("Internal error while evaluating expression: " + "unknown operation {}.".format(expr[0])) + + # # Internal classes # class _Feed(object): + """ + Class for working with sequences in a stream-like fashion; handy for + tokens. + """ - """Class for working with sequences in a stream-like fashion; handy for - tokens.""" - - # This would be more helpful on the item classes, but would remove some - # flexibility - __slots__ = ['items', 'length', 'i'] + __slots__ = ( + 'i', + 'length', + 'items', + ) def __init__(self, items): self.items = items self.length = len(self.items) self.i = 0 - def get_next(self): + def next(self): if self.i >= self.length: return None item = self.items[self.i] self.i += 1 return item - def peek_next(self): + def peek(self): return None if self.i >= self.length else self.items[self.i] def check(self, token): - """Check if the next token is 'token'. If so, remove it from the token - feed and return True. Otherwise, leave it in and return False.""" + """ + Checks if the next token is 'token'. If so, removes it from the token + feed and return True. Otherwise, leaves it in and return False. + """ if self.i < self.length and self.items[self.i] == token: self.i += 1 return True return False - def unget_all(self): - self.i = 0 - class _FileFeed(object): - - """Feeds lines from a file. Keeps track of the filename and current line + """ + Feeds lines from a file. Keeps track of the filename and current line number. Joins any line ending in \\ with the following line. We need to be - careful to get the line number right in the presence of continuation - lines.""" + careful to get the line number right in the presence of continuation lines. + """ - __slots__ = ['filename', 'lines', 'length', 'linenr'] + __slots__ = ( + 'filename', + 'lines', + 'length', + 'linenr' + ) - def __init__(self, filename): + def __init__(self, file_, filename): self.filename = filename - with open(filename) as f: + with file_: # No interleaving of I/O and processing yet. Don't know if it would # help. - self.lines = f.readlines() + self.lines = file_.readlines() self.length = len(self.lines) self.linenr = 0 - def get_next(self): + def next(self): if self.linenr >= self.length: return None line = self.lines[self.linenr] @@ -3368,73 +2975,61 @@ class _FileFeed(object): self.linenr += 1 return line - def peek_next(self): - linenr = self.linenr - if linenr >= self.length: + def next_no_join(self): + if self.linenr >= self.length: return None - line = self.lines[linenr] - while line.endswith("\\\n"): - linenr += 1 - line = line[:-2] + self.lines[linenr] + line = self.lines[self.linenr] + self.linenr += 1 return line - def unget(self): - self.linenr -= 1 - while self.lines[self.linenr].endswith("\\\n"): - self.linenr -= 1 - - def next_nonblank(self): - """Removes lines up to and including the next non-blank (not all-space) - line and returns it. Returns None if there are no more non-blank - lines.""" - while 1: - line = self.get_next() - if line is None or not line.isspace(): - return line - # # Internal functions # def _get_visibility(sc): - """Symbols and Choices have a "visibility" that acts as an upper bound on - the values a user can set for them, corresponding to the visibility in e.g. + """ + Symbols and Choices have a "visibility" that acts as an upper bound on the + values a user can set for them, corresponding to the visibility in e.g. 'make menuconfig'. This function calculates the visibility for the Symbol - or Choice 'sc' -- the logic is nearly identical.""" - if sc._cached_visibility is None: - vis = "n" - for _, cond_expr in sc._prompts: - vis = sc._config._eval_max(vis, cond_expr) - - if isinstance(sc, Symbol) and sc._is_choice_sym: - choice = sc._parent - if choice._type == TRISTATE and sc._type != TRISTATE and \ - choice.get_mode() != "y": - # Non-tristate choice symbols in tristate choices depend on the - # choice being in mode "y" - vis = "n" - elif sc._type == TRISTATE and vis == "m" and \ - choice.get_mode() == "y": - # Choice symbols with visibility "m" are not visible if the - # choice has mode "y" - vis = "n" - else: - vis = sc._config._eval_min(vis, _get_visibility(choice)) - - # Promote "m" to "y" if we're dealing with a non-tristate - if vis == "m" and sc._type != TRISTATE: - vis = "y" - - sc._cached_visibility = vis + or Choice 'sc' -- the logic is nearly identical. + """ + vis = "n" + + for node in sc.nodes: + if node.prompt: + vis = _eval_max(vis, node.prompt[1]) + + if isinstance(sc, Symbol) and sc.choice is not None: + if sc.choice._type == TRISTATE and sc._type != TRISTATE and \ + sc.choice.value != "y": + # Non-tristate choice symbols in tristate choices depend on the + # choice being in mode "y" + return "n" + + if sc._type == TRISTATE and vis == "m" and sc.choice.value == "y": + # Choice symbols with visibility "m" are not visible if the + # choice has mode "y" + return "n" + + vis = _eval_min(vis, sc.choice.visibility) + + # Promote "m" to "y" if we're dealing with a non-tristate. This might lead + # to infinite recursion if something really weird is done with MODULES, but + # it's not a problem in practice. + if vis == "m" and \ + (sc._type != TRISTATE or sc.config.modules.value == "n"): + return "y" - return sc._cached_visibility + return vis def _make_and(e1, e2): - """Constructs an _AND (&&) expression. Performs trivial simplification. - Nones equate to 'y'. + """ + Constructs an _AND (&&) expression. Performs trivial simplification. Nones + equate to 'y'. Returns None if e1 == e2 == None, so that ANDing two nonexistent - expressions gives a nonexistent expression.""" + expressions gives a nonexistent expression. + """ if e1 is None or e1 == "y": return e2 if e2 is None or e2 == "y": @@ -3442,9 +3037,11 @@ def _make_and(e1, e2): return (_AND, e1, e2) def _make_or(e1, e2): - """Constructs an _OR (||) expression. Performs trivial simplification and + """ + Constructs an _OR (||) expression. Performs trivial simplification and avoids Nones. Nones equate to 'y', which is usually what we want, but needs - to be kept in mind.""" + to be kept in mind. + """ # Perform trivial simplification and avoid None's (which # correspond to y's) @@ -3454,8 +3051,26 @@ def _make_or(e1, e2): return e2 return (_OR, e1, e2) +def _eval_min(e1, e2): + """ + Returns the minimum value of the two expressions. Equates None with 'y'. + """ + e1_eval = eval_expr(e1) + e2_eval = eval_expr(e2) + return e1_eval if tri_less(e1_eval, e2_eval) else e2_eval + +def _eval_max(e1, e2): + """ + Returns the maximum value of the two expressions. Equates None with 'y'. + """ + e1_eval = eval_expr(e1) + e2_eval = eval_expr(e2) + return e1_eval if tri_greater(e1_eval, e2_eval) else e2_eval + def _expr_syms_rec(expr, res): - """_expr_syms() helper. Recurses through expressions.""" + """ + _expr_syms() helper. Recurses through expressions. + """ if isinstance(expr, Symbol): res.append(expr) elif isinstance(expr, str): @@ -3475,29 +3090,37 @@ def _expr_syms_rec(expr, res): "expression with token stream {}.".format(expr)) def _expr_syms(expr, res): - """append()s the symbols in 'expr' to 'res'. Does not remove duplicates.""" + """ + append()s the symbols in 'expr' to 'res'. Does not remove duplicates. + """ if expr is not None: _expr_syms_rec(expr, res) def _str_val(obj): - """Returns the value of obj as a string. If obj is not a string (constant - symbol), it must be a Symbol.""" - return obj if isinstance(obj, str) else obj.get_value() + """ + Returns the value of obj as a string. If obj is not a string (constant + symbol), it must be a Symbol. + """ + return obj if isinstance(obj, str) else obj.value def _format_and_op(expr): - """_expr_to_str() helper. Returns the string representation of 'expr', - which is assumed to be an operand to _AND, with parentheses added if - needed.""" + """ + _expr_to_str() helper. Returns the string representation of 'expr', which + is assumed to be an operand to _AND, with parentheses added if needed. + """ if isinstance(expr, tuple) and expr[0] == _OR: return "({})".format(_expr_to_str(expr)) return _expr_to_str(expr) def _expr_to_str(expr): if isinstance(expr, str): + if expr in ("n", "m", "y"): + # Don't print spammy quotes for these + return expr return '"{}"'.format(expr) if isinstance(expr, Symbol): - return expr._name + return expr.name if expr[0] == _NOT: if isinstance(expr[1], (str, Symbol)): @@ -3518,21 +3141,27 @@ def _expr_to_str(expr): _expr_to_str(expr[2])) def _type_and_val(obj): - """Helper to hack around the fact that we don't represent plain strings as - Symbols. Takes either a plain string or a Symbol and returns a - (<type>, <value>) tuple.""" - return (obj._type, obj.get_value()) \ + """ + Helper to hack around the fact that we don't represent plain strings as + Symbols. Takes either a plain string or a Symbol and returns a (<type>, + <value>) tuple. + """ + return (obj._type, obj.value) \ if not isinstance(obj, str) \ else (STRING, obj) def _indentation(line): - """Returns the length of the line's leading whitespace, treating tab stops - as being spaced 8 characters apart.""" + """ + Returns the length of the line's leading whitespace, treating tab stops as + being spaced 8 characters apart. + """ line = line.expandtabs() return len(line) - len(line.lstrip()) def _deindent(line, indent): - """Deindent 'line' by 'indent' spaces.""" + """ + Deindents 'line' by 'indent' spaces. + """ line = line.expandtabs() if len(line) <= indent: return line @@ -3546,12 +3175,16 @@ def _is_base_n(s, n): return False def _strcmp(s1, s2): - """strcmp()-alike that returns -1, 0, or 1.""" + """ + strcmp()-alike that returns -1, 0, or 1. + """ return (s1 > s2) - (s1 < s2) def _lines(*args): - """Returns a string consisting of all arguments, with newlines inserted - between them.""" + """ + Returns a string consisting of all arguments, with newlines inserted + between them. + """ return "\n".join(args) def _stderr_msg(msg, filename, linenr): @@ -3561,26 +3194,313 @@ def _stderr_msg(msg, filename, linenr): def _tokenization_error(s, filename, linenr): loc = "" if filename is None else "{}:{}: ".format(filename, linenr) - raise Kconfig_Syntax_Error("{}Couldn't tokenize '{}'" + raise KconfigSyntaxError("{}Couldn't tokenize '{}'" .format(loc, s.strip())) def _parse_error(s, msg, filename, linenr): loc = "" if filename is None else "{}:{}: ".format(filename, linenr) - raise Kconfig_Syntax_Error("{}Couldn't parse '{}'{}" - .format(loc, s.strip(), - "." if msg is None else ": " + msg)) + raise KconfigSyntaxError("{}Couldn't parse '{}'{}" + .format(loc, s.strip(), + "." if msg is None else ": " + msg)) def _internal_error(msg): - raise Internal_Error( + raise InternalError( msg + "\nSorry! You may want to send an email to ulfalizer a.t Google's " "email service to tell me about this. Include the message above and " "the stack trace and describe what you were doing.") +# Printing functions + +def _sym_choice_str(sc): + """ + Symbol/choice __str__() implementation. These have many properties in + common, so it makes sense to handle them together. + """ + lines = [] + + def indent_add(s): + lines.append("\t" + s) + + # We print the prompt(s) and help text(s) too as a convenience, even though + # they're actually part of the menu node. If a symbol or choice is defined + # in multiple locations (has more than one menu node), we output one + # statement for each location, and print all the properties that belong to + # the symbol/choice itself only at the first location. This gives output + # that would function if fed to a Kconfig parser, even for such + # symbols/choices (choices defined in multiple locations gets iffy since + # they also have child nodes, but I've never seen such a choice). + + if not sc.nodes: + return "" + + for node in sc.nodes: + if isinstance(sc, Symbol): + if node.is_menuconfig: + lines.append("menuconfig " + sc.name) + else: + lines.append("config " + sc.name) + else: + if sc.name is None: + lines.append("choice") + else: + lines.append("choice " + sc.name) + + if node is sc.nodes[0] and sc.type != UNKNOWN: + indent_add(_TYPENAME[sc.type]) + + if node.prompt is not None: + prompt_str = 'prompt "{}"'.format(node.prompt[0]) + if node.prompt[1] is not None: + prompt_str += " if " + _expr_to_str(node.prompt[1]) + indent_add(prompt_str) + + if node is sc.nodes[0]: + if isinstance(sc, Symbol): + if sc.is_allnoconfig_y: + indent_add("option allnoconfig_y") + if sc is sc.config.defconfig_list: + indent_add("option defconfig_list") + if sc.env_var is not None: + indent_add('option env="{}"'.format(sc.env_var)) + if sc is sc.config.modules: + indent_add("option modules") + + if isinstance(sc, Symbol): + for range_ in sc.ranges: + range_string = "range {} {}" \ + .format(_expr_to_str(range_[0]), + _expr_to_str(range_[1])) + if range_[2] is not None: + range_string += " if " + _expr_to_str(range_[2]) + indent_add(range_string) + + for default in sc.defaults: + default_string = "default " + _expr_to_str(default[0]) + if default[1] is not None: + default_string += " if " + _expr_to_str(default[1]) + indent_add(default_string) + + if isinstance(sc, Choice) and sc.is_optional: + indent_add("optional") + + if isinstance(sc, Symbol): + for select in sc.selects: + select_string = "select " + select[0].name + if select[1] is not None: + select_string += " if " + _expr_to_str(select[1]) + indent_add(select_string) + + for imply in sc.implies: + imply_string = "imply " + imply[0].name + if imply[1] is not None: + imply_string += " if " + _expr_to_str(imply[1]) + indent_add(imply_string) + + if node.help is not None: + indent_add("help") + for line in node.help.splitlines(): + indent_add(" " + line) + + # Add a blank line if there are more nodes to print + if node is not sc.nodes[-1]: + lines.append("") + + return "\n".join(lines) + "\n" + +# Menu manipulation + +def _eq_to_sym(eq): + """ + _expr_depends_on() helper. For (in)equalities of the form sym = y/m or + sym != n, returns sym. For other (in)equalities, returns None. + """ + relation, left, right = eq + + # Make sure the symbol (if any) appears to the left + if not isinstance(left, Symbol): + left, right = right, left + if not isinstance(left, Symbol): + return None + if (relation == _EQUAL and right in ("m", "y")) or \ + (relation == _UNEQUAL and right == "n"): + return left + return None + +def _expr_depends_on(expr, sym): + """ + Reimplementation of expr_depends_symbol() from mconf.c. Used to + determine if a submenu should be implicitly created, which influences + what items inside choice statements are considered choice items. + """ + if expr is None: + return False + + def rec(expr): + if isinstance(expr, str): + return False + if isinstance(expr, Symbol): + return expr is sym + + if expr[0] in (_EQUAL, _UNEQUAL): + return _eq_to_sym(expr) is sym + if expr[0] == _AND: + return rec(expr[1]) or rec(expr[2]) + return False + + return rec(expr) + +def _has_auto_menu_dep(node1, node2): + """ + Returns True if node2 has an "automatic menu dependency" on node1. If node2 + has a prompt, we check its condition. Otherwise, we look directly at + node2.dep. + """ + + if node2.prompt: + return _expr_depends_on(node2.prompt[1], node1.item) + + # If we have no prompt, use the menu node dependencies instead + return node2.dep is not None and \ + _expr_depends_on(node2.dep, node1.item) + +def _check_auto_menu(node): + """ + Looks for menu nodes after 'node' that depend on it. Creates an implicit + menu rooted at 'node' with the nodes as the children if such nodes are + found. The recursive call to _finalize_tree() makes this work recursively. + """ + + cur = node + while cur.next is not None and \ + _has_auto_menu_dep(node, cur.next): + _finalize_tree(cur.next) + cur = cur.next + cur.parent = node + + if cur is not node: + node.list = node.next + node.next = cur.next + cur.next = None + +def _flatten(node): + """ + "Flattens" menu nodes without prompts (e.g. 'if' nodes and non-visible + symbols with children from automatic menu creation) so that their children + appear after them instead. This gives a clean menu structure with no + unexpected "jumps" in the indentation. + """ + + while node is not None: + if node.list is not None and \ + (node.prompt is None or node.prompt == ""): + + last_node = node.list + while 1: + last_node.parent = node.parent + if last_node.next is None: + break + last_node = last_node.next + + last_node.next = node.next + node.next = node.list + node.list = None + + node = node.next + +def _remove_if(node): + """ + Removes 'if' nodes (which can be recognized by MenuNode.item being None), + which are assumed to already have been flattened. The C implementation + doesn't bother to do this, but we expose the menu tree directly, and it + makes it nicer to work with. + """ + first = node.list + while first is not None and first.item is None: + first = first.next + + cur = first + while cur is not None: + if cur.next is not None and cur.next.item is None: + cur.next = cur.next.next + cur = cur.next + + node.list = first + +def _finalize_choice(node): + """ + Finalizes a choice, marking each symbol whose menu node has the choice as + the parent as a choice symbol, and automatically determining types if not + specified. + """ + choice = node.item + + cur = node.list + while cur is not None: + if isinstance(cur.item, Symbol): + cur.item.choice = choice + choice.syms.append(cur.item) + cur = cur.next + + # If no type is specified for the choice, its type is that of + # the first choice item with a specified type + if choice._type == UNKNOWN: + for item in choice.syms: + if item._type != UNKNOWN: + choice._type = item._type + break + + # Each choice item of UNKNOWN type gets the type of the choice + for item in choice.syms: + if item._type == UNKNOWN: + item._type = choice._type + +def _finalize_tree(node): + """ + Creates implicit menus from dependencies (see kconfig-language.txt), + removes 'if' nodes, and finalizes choices. This pretty closely mirrors + menu_finalize() from the C implementation, though we propagate dependencies + during parsing instead. + """ + + # The ordering here gets a bit tricky, but it's important to do things in + # this order to have everything work out correctly. + + if node.list is not None: + # The menu node has children. Finalize them. + cur = node.list + while cur is not None: + _finalize_tree(cur) + # Note: _finalize_tree() might have changed cur.next. This is + # expected, so that we jump over e.g. implicitly created submenus. + cur = cur.next + + elif node.item is not None: + # The menu node has no children (yet). See if we can create an implicit + # menu rooted at it (due to menu nodes after it depending on it). + _check_auto_menu(node) + + if node.list is not None: + # We have a node with finalized children. Do final steps to finalize + # this node. + _flatten(node.list) + _remove_if(node) + + # Empty choices (node.list None) are possible, so this needs to go outside + if isinstance(node.item, Choice): + _finalize_choice(node) + # # Public global constants # +# Integers representing menu and comment nodes + +( + MENU, + COMMENT, +) = range(2) + # Integers representing symbol types ( BOOL, @@ -3625,6 +3545,7 @@ def _internal_error(msg): _T_LESS_EQUAL, _T_MAINMENU, _T_MENU, + _T_MENUCONFIG, _T_MODULES, _T_NOT, _T_ON, @@ -3640,7 +3561,7 @@ def _internal_error(msg): _T_TRISTATE, _T_UNEQUAL, _T_VISIBLE, -) = range(43) +) = range(44) # Keyword to token map. Note that the get() method is assigned directly as a # small optimization. @@ -3667,13 +3588,7 @@ _get_keyword = { "int": _T_INT, "mainmenu": _T_MAINMENU, "menu": _T_MENU, - - # 'menuconfig' only deals with presentation in the configuration interface - # and doesn't affect evaluation semantics, so treat it the same as - # 'config'. Perhaps some presentation-related support could be added as - # well. - "menuconfig": _T_CONFIG, - + "menuconfig": _T_MENUCONFIG, "modules": _T_MODULES, "on": _T_ON, "option": _T_OPTION, @@ -3687,12 +3602,10 @@ _get_keyword = { "visible": _T_VISIBLE, }.get -# Tokens after which identifier-like lexemes are treated as strings, plus -# _T_CONFIG. This allows us to quickly check if we have a symbol reference (as -# opposed to a definition or something else) when tokenizing. -_NOT_REF = frozenset(( +# Tokens after which identifier-like lexemes are treated as strings. _T_CHOICE +# is included to avoid symbols being registered for named choices. +_STRING_LEX = frozenset(( _T_BOOL, - _T_CONFIG, _T_CHOICE, _T_COMMENT, _T_HEX, @@ -3761,8 +3674,10 @@ _DEFAULT_VALUE = { STRING: "", } -# Indicates that no item is selected in a choice statement -_NO_SELECTION = 0 +# Constant representing that there's no cached choice selection. This is +# distinct from a cached None (no selection). We create a unique object (any +# will do) for it so we can test with 'is'. +_NO_CACHED_SELECTION = object() # Integers representing expression types ( @@ -3806,7 +3721,7 @@ _RELATIONS = frozenset(( )) # Token to relation (=, !=, <, ...) mapping -_TOKEN_TO_RELATION = { +_TOKEN_TO_REL = { _T_EQUAL: _EQUAL, _T_GREATER: _GREATER, _T_GREATER_EQUAL: _GREATER_EQUAL, diff --git a/makefile.patch b/makefile.patch index e8c4425..aefb021 100644 --- a/makefile.patch +++ b/makefile.patch @@ -38,7 +38,7 @@ index d9b1fef..e6311ed 100644 + "import kconfiglib; \ + import sys; \ + c = kconfiglib.Config(sys.argv[4 if \"$(PYTHONCMD)\".startswith(\"ipython\") else 1]); \ -+ print(\"A Config instance 'c' for the architecture ({0}) has been created.\".format(c.get_arch()))" \ ++ print(\"A Config instance 'c' for the architecture has been created.\")" \ + $(srctree)/$(Kconfig) + +# Used by testsuite.py to be able to compare output for nonsensical diff --git a/tests/Kchoice b/tests/Kchoice index e80e222..f635ccc 100644 --- a/tests/Kchoice +++ b/tests/Kchoice @@ -141,17 +141,39 @@ choice WEIRD_SYMS # Only WS1 is part of the choice config WS1 + bool "WS1" + config WS2 + bool "WS2" depends on WS1 + config WS3 + bool depends on WS2 + config WS4 + bool depends on WS1 -# 'if' has the same effect, so only WS5 is part of the choice config WS5 -if WS5 + bool "WS5" if WS1 + +# 'if' has the same effect, so only WS6 is part of the choice config WS6 + bool "WS6" + +if WS6 + +config WS7 + bool + +config WS8 + bool "WS8" + endif +# Should also be part of the choice +config WS9 + bool "WS9" + endchoice diff --git a/tests/Kdefconfig_existent b/tests/Kdefconfig_existent index 895c218..8dde443 100644 --- a/tests/Kdefconfig_existent +++ b/tests/Kdefconfig_existent @@ -2,6 +2,7 @@ # Should produce "Kconfiglib/tests/defconfig_2" config FOO + string option env="BAR" config A diff --git a/tests/Keval b/tests/Keval index 64bd4d8..4f63247 100644 --- a/tests/Keval +++ b/tests/Keval @@ -1,6 +1,7 @@ # Enabled/disabled in the test config MODULES bool "modules" + option modules config N def_tristate n diff --git a/tests/Klocation b/tests/Klocation index 404e5ae..498a372 100644 --- a/tests/Klocation +++ b/tests/Klocation @@ -1,73 +1,30 @@ -# Include some line continuations to make sure they don't mess up line numbers +if UNDEFINED +endif -# Defined and referenced in multiple locations -config A - bool +config SINGLE_DEF + +config MULTI_DEF # Throw in some line continuations too to make sure it doesn't mess up the line # numbers -menu "menu 1" - depends on A - visible if A && \ - NOT_DEFINED - -# Also defined in Klocation_included -choice B - bool "b" if A - -config C - bool "c" - -config D - bool "d" - -\ - -endchoice +if y && \ + y +if y && \ + y && \ + y -config A - def_bool NOT_DEFINED +config MULTI_DEF -comment "comment 1" +endif +endif -config E - bool "E" if A - depends on A - -endmenu - -config \ - FOO +config EXPANDED_FROM_ENV string - option \ - env\ - =\ - "FOO" - -\ -\ + option env="EXPANDED_FROM_ENV" -config BAR +config _INCLUDED string - default \ - "_included" + default "_included" # Expands to "tests/Klocation_included" -source \ -"$FOO/Klocation$BAR" - -\ -\ -\ - -config I - int - range A 0 - range 0 A - range 0 1 if A - default J if A < 0 - default K if 0 < A - default L if 0 <= A - default M if 0 > A - default N if 0 >= A - default N if y && 0 < A +source "$EXPANDED_FROM_ENV/Klocation$_INCLUDED" diff --git a/tests/Klocation_included b/tests/Klocation_included index 674116a..fb1afaa 100644 --- a/tests/Klocation_included +++ b/tests/Klocation_included @@ -1,42 +1,15 @@ -menuconfig A - bool "A" -menuconfig A - bool "A" -menu "menu 2" -config M - def_bool !(n || (n || A = n)) - default !A if y - default y if !A -config S - bool - select A if NOT_DEFINED = y - select E if A - imply A - imply E if A -endmenu -choice - bool "C" -config N - bool "N" -config O - bool "O" -endchoice -choice B - bool "B" -config B1 - tristate "B1" -config B2 - tristate "B2" +config MULTI_DEF +choice CHOICE endchoice -if !(NOT_DEFINED != A) -comment "comment 2" -endif +config MENU_HOOK -menu "visible if menu" - visible if A - visible if NOT_DEFINED +menu "menu" endmenu + +config COMMENT_HOOK + +comment "comment" diff --git a/tests/Kmisc b/tests/Kmisc index d2e55b2..c3a21f8 100644 --- a/tests/Kmisc +++ b/tests/Kmisc @@ -1,6 +1,6 @@ # For testing various minor APIs -# is_optional() +# optional choices choice NOT_OPTIONAL bool "not optional" diff --git a/tests/Kmodifiable b/tests/Kmodifiable deleted file mode 100644 index 1f9dcc9..0000000 --- a/tests/Kmodifiable +++ /dev/null @@ -1,50 +0,0 @@ -config MODULES - def_bool y - -config VISIBLE - tristate "bool visible" - -config NOT_VISIBLE - tristate - -config Y_SELECTOR - def_tristate y - select SELECTED_TO_Y - -config SELECTED_TO_Y - tristate "selected to y" - -config M_SELECTOR - def_tristate m - select TRISTATE_SELECTED_TO_M - select M_VISIBLE_TRISTATE_SELECTED_TO_M - select BOOL_SELECTED_TO_M - -config TRISTATE_SELECTED_TO_M - tristate "tristate selected to m" - -config M_VISIBLE_TRISTATE_SELECTED_TO_M - tristate "m-visible tristate selected to m" - depends on m - -# The "m" will get promoted to a "y", so this should still not be modifiable -config BOOL_SELECTED_TO_M - bool "bool selected to m" - -config VISIBLE_STRING - string "visible string" - -config VISIBLE_INT - int "visible int" - -config VISIBLE_HEX - hex "visible hex" - -config NOT_VISIBLE_STRING - string - -config NOT_VISIBLE_INT - int "not visible int" if n - -config NOT_VISIBLE_HEX - hex diff --git a/tests/Kprompt b/tests/Kprompt deleted file mode 100644 index a36a0fd..0000000 --- a/tests/Kprompt +++ /dev/null @@ -1,77 +0,0 @@ -config NO_PROMPT - tristate - -config SINGLE_PROMPT_1 - bool "single prompt 1" - -config SINGLE_PROMPT_2 - bool - prompt "single prompt 2" if n - -config MULTI_PROMPT - bool "ignored prompt" - prompt "prompt 1" -config MULTI_PROMPT - bool "prompt 2" -config MULTI_PROMPT - bool -config MULTI_PROMPT - bool - prompt "prompt 3" -config MULTI_PROMPT - bool - prompt "ignored prompt" - prompt "ignored prompt 2" if y - prompt "prompt 4" if y - -choice NO_PROMPT_CHOICE - tristate -config A - bool -config B - bool -endchoice - -choice SINGLE_PROMPT_1_CHOICE - bool "single prompt 1 choice" -config C - bool -config D - bool -endchoice - -choice SINGLE_PROMPT_2_CHOICE - bool "ignored prompt" - prompt "single prompt 2 choice" -config E - bool -config F - bool -endchoice - -choice MULTI_PROMPT_CHOICE - bool "prompt 1 choice" -config G - bool -config H - bool -endchoice - -choice MULTI_PROMPT_CHOICE - bool - prompt "prompt 2 choice" -config I - bool -config J - bool -endchoice - -choice MULTI_PROMPT_CHOICE - bool - prompt "ignored prompt" - prompt "prompt 3 choice" -config K - bool -config L - bool -endchoice diff --git a/tests/Krelation b/tests/Krelation index 057b585..420152f 100644 --- a/tests/Krelation +++ b/tests/Krelation @@ -1,5 +1,6 @@ config A bool + depends on UNDEFINED choice bool "C" @@ -18,6 +19,7 @@ menu "m2" config F bool choice + tristate "foo" config G bool "g" config H diff --git a/tests/Krepr b/tests/Krepr new file mode 100644 index 0000000..d886fe3 --- /dev/null +++ b/tests/Krepr @@ -0,0 +1,61 @@ +config MODULES + bool + option modules + default y + +if UNDEFINED +endif + +config BASIC + bool + default y + help + +config VISIBLE + bool "visible" + +config DIR_DEP_N + depends on n + +config OPTIONS + option allnoconfig_y + option defconfig_list + option env="ENV" + +config MULTI_DEF +config MULTI_DEF + +menuconfig MENUCONFIG + +choice CHOICE + tristate "choice" + +config CHOICE_1 + tristate "choice sym" + +config CHOICE_2 + tristate "choice sym" + +endchoice + +config CHOICE_HOOK + +choice + tristate "choice" if n + optional +endchoice + +config NO_VISIBLE_IF_HOOK + +menu "no visible if" +endmenu + +config VISIBLE_IF_HOOK + +menu "visible if" + visible if m +endmenu + +config COMMENT_HOOK + +comment "comment" diff --git a/tests/Kstr b/tests/Kstr new file mode 100644 index 0000000..8d74017 --- /dev/null +++ b/tests/Kstr @@ -0,0 +1,76 @@ +if UNDEFINED +endif + +config NO_TYPE + +config BASIC_NO_PROMPT + bool + help + blah blah + + blah blah blah + + blah + +config BASIC_PROMPT + bool "basic" + +config ADVANCED + tristate "prompt" if DEP + default DEFAULT_1 + default DEFAULT_2 if DEP + select SELECTED_1 + select SELECTED_2 if DEP + imply IMPLIED_1 + imply IMPLIED_2 if DEP + help + first help text + +config ADVANCED + prompt "prompt 2" + +menuconfig ADVANCED + prompt "prompt 3" + depends on DEP2 + +config ADVANCED + help + second help text + +config STRING + string + default "foo" + default "bar" if DEP + default STRING2 + default STRING3 if DEP + +config INT + int + range 1 2 + range FOO BAR + range BAZ QAZ if DEP + +config MODULES + option modules + +config OPTIONS + option allnoconfig_y + option defconfig_list + option env="ENV" + +choice CHOICE + tristate "foo" + default CHOICE_1 + default CHOICE_2 if dep + +config CHOICE_1 + tristate "choice 1" + +config CHOICE_2 + tristate "choice 2" + +endchoice + +choice + tristate "no name" +endchoice diff --git a/tests/Ktext b/tests/Ktext deleted file mode 100644 index 3440c3c..0000000 --- a/tests/Ktext +++ /dev/null @@ -1,145 +0,0 @@ -config BASIC - bool - -if !BASIC && !BASIC - -config ADVANCED - tristate "advanced prompt 1" if y || (BASIC && BASIC) - select SELECTED_1 if BASIC && DUMMY - select SELECTED_2 if !(DUMMY || BASIC) - imply IMPLIED_1 if BASIC || DUMMY - imply IMPLIED_2 if !(DUMMY && BASIC) - default y if BASIC && !BASIC - default n if BASIC = DUMMY && X < Y && X <= Y && X > Y && X >= Y - -config ADVANCED - tristate "advanced prompt 2" - -config STRING - string - default "foo" - default "bar" if BAR - default STRING2 if BAZ - -config STRING2 - string - default "baz" - -endif - -config SELECTED_1 -config SELECTED_2 -config SELECTING_1 - select ADVANCED if BASIC -config SELECTING_2 - select ADVANCED if !BASIC -config IMPLYING_1 - imply ADVANCED if DUMMY -config IMPLYING_2 - imply ADVANCED if !DUMMY - -config INT - int - default 7 - -config HAS_RANGES - int "ranged" - range 1 2 if !DUMMY - range INT INT if DUMMY - range 123 456 - -choice - bool "choice" - -config CHOICE_ITEM_1 - bool "A" -config CHOICE_ITEM_2 - bool "B" -config CHOICE_ITEM_3 - bool "C" - -endchoice - -menu "simple menu" -endmenu - -if !DUMMY -menu "advanced menu" - depends on !BASIC - visible if !DUMMY -endmenu -endif - -comment "simple comment" - -if !DUMMY - comment "advanced comment" - depends on !BASIC -endif - -config NO_HELP - bool - -choice NO_HELP_CHOICE -config FOO -endchoice - -config EMPTY_HELP - bool - help -config DUMMY - -choice EMPTY_HELP_CHOICE - bool - help -config DUMMY2 -endchoice - -config S - bool - help - help for - S -choice C - bool - help - help for - C -config A - bool "A" - -config B - bool "B" - -endchoice - -comment "a comment" - -menu "a menu" -endmenu - -config HELP_TERMINATED_BY_COMMENT - bool - help - a - b - c -# - -config TRICKY_HELP - bool - help - - - a - b - c - - d - e - f - - - g - h - i diff --git a/tests/Kvisibility b/tests/Kvisibility index 715d098..91def0a 100644 --- a/tests/Kvisibility +++ b/tests/Kvisibility @@ -1,5 +1,6 @@ config MODULES bool "MODULES" + option modules # # Symbol visibility @@ -12,186 +13,204 @@ config NO_PROMPT config MOD def_tristate m -config BOOL_n +config BOOL_N bool "bool n" if n -# Rewritten to m && MODULES -config BOOL_m +config BOOL_M + # Rewritten to m && MODULES bool "bool m" if m -# Not rewritten config BOOL_MOD bool "bool MOD" + # Not rewritten depends on MOD -# Rewritten to m && MODULES -config BOOL_y +config BOOL_Y bool "bool y" + # Rewritten to m && MODULES depends on y || m -config TRISTATE_n +config TRISTATE_N tristate "tristate n" if n -# Rewritten to m && MODULES -config TRISTATE_m +config TRISTATE_M + # Rewritten to m && MODULES tristate "tristate m" if m -# Not rewritten config TRISTATE_MOD tristate "tristate MOD" + # Not rewritten depends on MOD -# Rewritten to m && MODULES -config TRISTATE_y +config TRISTATE_Y bool "tristate y" + # Rewritten to m && MODULES depends on y || m # Symbols nested in 'if' if n -config BOOL_if_n + +config BOOL_IF_N bool "bool if n" -config TRISTATE_if_n + +config TRISTATE_IF_N tristate "tristate if n" + endif if m -config BOOL_if_m + +config BOOL_IF_M bool "bool if m" -config TRISTATE_if_m + +config TRISTATE_IF_M tristate "tristate if n" + endif if y -config BOOL_if_y + +config BOOL_IF_Y bool "bool if y" -config TRISTATE_if_y + +config TRISTATE_IF_Y tristate "tristate if y" + endif # Symbols nested in 'menu' menu "menu 1" depends on n -config BOOL_menu_n + +config BOOL_MENU_N bool "bool menu n" -config TRISTATE_menu_n + +config TRISTATE_MENU_N tristate "tristate menu n" + endmenu menu "menu 2" depends on m -config BOOL_menu_m + +config BOOL_MENU_M bool "bool menu m" -config TRISTATE_menu_m + +config TRISTATE_MENU_M tristate "tristate menu n" + endmenu menu "menu 3" depends on y -config BOOL_menu_y + +config BOOL_MENU_Y bool "bool menu y" -config TRISTATE_menu_y + +config TRISTATE_MENU_Y tristate "tristate menu y" + endmenu # Symbols nested in choices choice C1 tristate "choice n" if n -config BOOL_choice_n + +config BOOL_CHOICE_N bool "bool choice n" -config TRISTATE_choice_n + +config TRISTATE_CHOICE_N tristate "tristate choice n" + endchoice choice C2 tristate "choice m" if m -config BOOL_choice_m + +config BOOL_CHOICE_M bool "bool choice m" -config TRISTATE_choice_m + +config TRISTATE_CHOICE_M tristate "tristate choice n" + endchoice choice C3 tristate "choice y" if y -config BOOL_choice_y + +config BOOL_CHOICE_Y bool "bool choice y" -config TRISTATE_choice_y + +config TRISTATE_CHOICE_Y tristate "tristate choice y" + endchoice # # Choice visibility # -choice BOOL_CHOICE_n +choice BOOL_CHOICE_N bool "bool choice n" if n -config A - bool "A" -config B - bool "B" endchoice -choice BOOL_CHOICE_m +choice BOOL_CHOICE_M bool "bool choice m" if m -config C - bool "C" -config D - bool "D" endchoice -choice BOOL_CHOICE_y +choice BOOL_CHOICE_Y bool "bool choice y" if y -config E - bool "E" -config F - bool "F" endchoice -choice TRISTATE_CHOICE_n +choice TRISTATE_CHOICE_N tristate "tristate choice n" if n -config G - tristate "G" -config H - tristate "H" endchoice -choice TRISTATE_CHOICE_m +choice TRISTATE_CHOICE_M tristate "tristate choice m" if m -config I - tristate "I" -config J - tristate "J" endchoice -choice TRISTATE_CHOICE_y +choice TRISTATE_CHOICE_Y tristate "tristate choice y" if y + config K tristate "K" + config L tristate "L" + endchoice if m -choice TRISTATE_CHOICE_IF_m_and_y +choice TRISTATE_CHOICE_IF_M_AND_Y tristate "tristate choice if m and y" if y + config M bool "M" + config N bool "N" + endchoice endif menu "choice-containing menu" depends on n && y -choice TRISTATE_CHOICE_MENU_n_and_y + +choice TRISTATE_CHOICE_MENU_N_AND_Y tristate "tristate choice if n and y" + config O tristate "O" + config P tristate "P" + endchoice + endmenu # @@ -245,19 +264,25 @@ comment "comment y" if n comment "comment if n" endif + if m comment "comment if m" endif + if y comment "comment if y" endif if "y" -menu "comment-containing menu" + +menu "menu with comment" depends on m + comment "double-nested m comment" depends on y + endmenu + endif # Used to verify that string/int/hex symbols with m visibility accept a user @@ -280,28 +305,38 @@ endif menu "n-visible menu" visible if n -config VISIBLE_IF_n + +config VISIBLE_IF_N tristate "visible if n" + endmenu menu "m-visible menu" visible if m -config VISIBLE_IF_m + +config VISIBLE_IF_M tristate "visible if m" + endmenu menu "y-visible menu" visible if y -config VISIBLE_IF_y + +config VISIBLE_IF_Y tristate "visible if m" + endmenu menu "m-visible menu 2" visible if y || n visible if m && y visible if y + if y -config VISIBLE_IF_m_2 + +config VISIBLE_IF_M_2 tristate "visible if m 2" + endif + endmenu diff --git a/testsuite.py b/testsuite.py index 11822ce..69eae6e 100644 --- a/testsuite.py +++ b/testsuite.py @@ -1,45 +1,40 @@ -# This is a test suite for Kconfiglib. It runs selftests on Kconfigs provided -# by us and tests compatibility with the C Kconfig implementation by comparing -# the output of Kconfiglib with the output of the scripts/kconfig/*conf -# utilities for different targets and defconfigs. It should be run from the -# top-level kernel directory with +# This is the Kconfiglib test suite. It runs selftests on Kconfigs provided by +# us and tests compatibility with the C Kconfig implementation by comparing the +# output of Kconfiglib with the output of the scripts/kconfig/*conf utilities +# for different targets and defconfigs. It should be run from the top-level +# kernel directory with # -# $ python Kconfiglib/testsuite.py +# $ python Kconfiglib/testsuite.py # -# Some additional options can be turned on by passing arguments. With no argument, -# they default to off. +# Some additional options can be turned on by passing them as arguments. They +# default to off. # # - speedy: -# Run scripts/kconfig/conf directly when comparing outputs instead of using -# 'make' targets. Makes things a lot faster, but could break if Kconfig -# files start depending on additional environment variables besides ARCH and -# SRCARCH. (These would be set in the Makefiles in that case.) Safe as of -# Linux 4.1.0-rc8. +# Run scripts/kconfig/conf directly instead of using 'make' targets. Makes +# things a lot faster, but could break if Kconfig files start referencing +# additional environment variables beyond ARCH, SRCARCH, and KERNELVERSION. +# Safe as of Linux 4.14-rc3. # # - obsessive: -# By default, only valid arch/defconfig pairs will be tested. With this -# enabled, every arch will be tested with every defconfig, which increases -# the test time by an order of magnitude. Occasionally finds (usually very -# obscure) bugs, and I make sure everything passes with it. +# By default, only valid arch/defconfig pairs are tested. In obsessive mode, +# every arch will be tested with every defconfig. Increases the testing time +# by an order of magnitude. Occasionally finds (usually obscure) bugs, and I +# make sure everything passes with it. # # - log: -# Log timestamped failures of the defconfig test to test_defconfig_fails in -# the root. Especially handy in obsessive mode. +# Log timestamped defconfig test failures to the file test_defconfig_fails. +# Handy in obsessive mode. # -# For example, to run in speedy mode with logging, run +# For example, this commands runs the test suite in speedy mode with logging +# enabled: # -# $ python Kconfiglib/testsuite.py speedy log +# $ python(3) Kconfiglib/testsuite.py speedy log # -# (PyPy also works, and runs the defconfig tests roughly 20% faster on my -# machine. Some of the other tests get an even greater speed-up.) -# -# The tests have been roughly arranged in order of time needed. +# pypy works too, and runs most tests much faster than CPython. # # All tests should pass. Report regressions to ulfalizer a.t Google's email # service. -from __future__ import print_function - import difflib import errno import kconfiglib @@ -51,101 +46,179 @@ import sys import textwrap import time -speedy_mode = False -obsessive_mode = False -log_mode = False +def shell(cmd): + with open(os.devnull, "w") as devnull: + subprocess.call(cmd, shell=True, stdout=devnull, stderr=devnull) + +all_passed = True + +def fail(msg=None): + global all_passed + all_passed = False + if msg is not None: + print("Fail: " + msg) + +def verify(cond, msg): + if not cond: + fail(msg) + +def verify_equal(x, y): + if x != y: + fail("'{}' does not equal '{}'".format(x, y)) # Assign this to avoid warnings from Kconfiglib. Nothing in the kernel's # Kconfig files seems to actually look at the value as of 3.7.0-rc8. This is # only relevant for the test suite, as this will get set by the kernel Makefile # when using (i)scriptconfig. -os.environ["KERNELVERSION"] = "3.7.0" +os.environ["KERNELVERSION"] = "1" # Prevent accidental loading of configuration files by removing # KCONFIG_ALLCONFIG from the environment os.environ.pop("KCONFIG_ALLCONFIG", None) +speedy = False +obsessive = False +log = False + # Number of arch/defconfig pairs tested so far nconfigs = 0 def run_tests(): - global speedy_mode, obsessive_mode, log_mode + global speedy, obsessive, log for s in sys.argv[1:]: if s == "speedy": - speedy_mode = True + speedy = True print("Speedy mode enabled") elif s == "obsessive": - obsessive_mode = True + obsessive = True print("Obsessive mode enabled") elif s == "log": - log_mode = True + log = True print("Log mode enabled") else: print("Unrecognized option '{}'".format(s)) - return run_selftests() run_compatibility_tests() -def run_selftests(): - """Runs tests on specific configurations provided by us.""" +def get_items(config, type_): + items = [] + def rec(node): + if node is not None: + if isinstance(node.item, type_): + items.append(node.item) + rec(node.list) + rec(node.next) + rec(config.top_menu) + return items + +def get_comments(config): + items = [] + def rec(node): + if node is not None: + if node.item == kconfiglib.COMMENT: + items.append(node) + rec(node.list) + rec(node.next) + rec(config.top_menu) + return items + +def get_menus(config): + items = [] + def rec(node): + if node is not None: + if node.item == kconfiglib.MENU: + items.append(node) + rec(node.list) + rec(node.next) + rec(config.top_menu) + return items + +def get_choices(config): + choices = get_items(config, kconfiglib.Choice) + unique_choices = [] + for choice in choices: + if choice not in unique_choices: + unique_choices.append(choice) + return unique_choices + +def get_parent(item): + if isinstance(item, (kconfiglib.Symbol, kconfiglib.Choice)): + if not item.nodes: + return None + return item.nodes[0].parent.item + return item.node.parent.item + +def get_prompts(item): + prompts = [] + for node in item.nodes: + if node.prompt is not None: + prompts.append(node.prompt[0]) + return prompts +def run_selftests(): # - # Helper functions + # Common helper functions. These all expect 'c' to hold the current + # configuration. # def verify_value(sym_name, val): - """Verifies that a symbol has a particular value.""" - sym = c[sym_name] - sym_val = sym.get_value() - verify(sym_val == val, - "{} should have the value '{}' but has the value '{}'" - .format(sym_name, val, sym_val)) - - def assign_and_verify_new_value(sym_name, user_val, new_val): - """Assigns a user value to the symbol and verifies the new value.""" - sym = c[sym_name] - sym_old_val = sym.get_value() - sym.set_user_value(user_val) - sym_new_val = sym.get_value() - verify(sym_new_val == new_val, - "{} should have the new value '{}' after being assigned the " - "user value '{}'. Instead, the value is '{}'. The old " - "value was '{}'." - .format(sym_name, new_val, user_val, sym_new_val, sym_old_val)) + """ + Verifies that a symbol has a particular value. + """ + sym = c.syms[sym_name] + verify(sym.value == val, + 'expected {} to have the value "{}", had the value "{}"' + .format(sym_name, val, sym.value)) + + def assign_and_verify_value(sym_name, val, new_val): + """ + Assigns 'val' to a symbol and verifies that its value becomes + 'new_val'. + """ + sym = c.syms[sym_name] + old_val = sym.value + sym.set_value(val) + verify(sym.value == new_val, + 'expected {} to have the value "{}" after being assigned the ' + 'value "{}". Instead, the value is "{}". The old value was ' + '"{}".' + .format(sym_name, new_val, val, sym.value, old_val)) def assign_and_verify(sym_name, user_val): - """Like assign_and_verify_new_value(), with the expected value being - the value just set.""" - assign_and_verify_new_value(sym_name, user_val, user_val) + """ + Like assign_and_verify_value(), with the expected value being the + value just set. + """ + assign_and_verify_value(sym_name, user_val, user_val) - def assign_and_verify_new_user_value(sym_name, user_val, new_user_val): + def assign_and_verify_user_value(sym_name, val, user_val): """Assigns a user value to the symbol and verifies the new user value.""" - sym = c[sym_name] - sym_old_user_val = sym.get_user_value() - sym.set_user_value(user_val) - sym_new_user_val = sym.get_user_value() - verify(sym_new_user_val == new_user_val, + sym = c.syms[sym_name] + sym_old_user_val = sym.user_value + sym.set_value(val) + verify(sym.user_value == user_val, "{} should have the user value '{}' after being assigned " "the user value '{}'. Instead, the new user value was '{}'. " "The old user value was '{}'." - .format(sym_name, new_user_val, user_val, sym_new_user_val, + .format(sym_name, user_val, user_val, sym.user_value, sym_old_user_val)) - print("Running selftests...\n") + # + # Selftests + # - print("Testing tristate comparisons...") + print("Testing tristate comparisons") - def verify_truth_table(comp_fn, *bools): - bools_list = list(bools) - for (x, y) in (("n", "n"), ("n", "m"), ("n", "y"), - ("m", "n"), ("m", "m"), ("m", "y"), - ("y", "n"), ("y", "m"), ("y", "y")): - expected = bools_list.pop(0) + def verify_truth_table(comp_fn, *table): + for (x, y), expected in zip((("n", "n"), ("n", "m"), ("n", "y"), + ("m", "n"), ("m", "m"), ("m", "y"), + ("y", "n"), ("y", "m"), ("y", "y")), + table): verify(comp_fn(x, y) == expected, - "Expected {} on ('{}', '{}') to be {}". + "expected {} on ('{}', '{}') to be '{}'". format(comp_fn, x, y, expected)) verify_truth_table(kconfiglib.tri_less, @@ -168,23 +241,23 @@ def run_selftests(): True, True, False, True, True, True) - # - # String literal lexing. (This tests an internal API.) - # - print("Testing string literal (constant symbol) lexing...") + print("Testing string literal (constant symbol) lexing") + # Dummy empty configuration just to get a Config object c = kconfiglib.Config("Kconfiglib/tests/empty") def verify_string_lex(s, res): - """Verifies that the string token 'res' is produced from lexing 's'. - Strips the first and last characters from 's' so we can use readable - raw strings as input.""" + """ + Verifies that the string (constant symbol) token 'res' is produced from + lexing 's'. Strips the first and last characters from 's' so that + readable raw strings can be used as input + """ s = s[1:-1] - s_res = c._tokenize(s, for_eval = True).get_next() - verify(s_res == res, - "'{}' produced the string token '{}'. Expected '{}'." - .format(s, s_res, res)) + token = c._tokenize(s, for_eval = True).next() + verify(token == res, + "expected {} to produced the string token {}, produced {}" + .format(s, token, res)) verify_string_lex(r""" "" """, "") verify_string_lex(r""" '' """, "") @@ -215,16 +288,18 @@ def run_selftests(): verify_string_lex(r""" '\a\\"\b\c\'"d' """, "a\\\"bc'\"d") def verify_string_bad(s): - """Verifies that tokenizing 's' throws a Kconfig_Syntax_Error. Strips - the first and last characters from 's' so we can use readable raw - strings as input.""" + """ + Verifies that tokenizing 's' throws a KconfigSyntaxError. Strips the + first and last characters from 's' so we can use readable raw strings + as input. + """ s = s[1:-1] try: c._tokenize(s, for_eval = True) - except kconfiglib.Kconfig_Syntax_Error: + except kconfiglib.KconfigSyntaxError: pass else: - fail("Tokenization of '{}' should have failed.".format(s)) + fail("expected tokenization of {} to fail, didn't".format(s)) verify_string_bad(r""" " """) verify_string_bad(r""" ' """) @@ -235,115 +310,18 @@ def run_selftests(): verify_string_bad(r""" "foo """) verify_string_bad(r""" 'foo """) - # - # is_modifiable() - # - - print("Testing is_modifiable() and range queries...") - - c = kconfiglib.Config("Kconfiglib/tests/Kmodifiable") - - for sym_name in ("VISIBLE", "TRISTATE_SELECTED_TO_M", "VISIBLE_STRING", - "VISIBLE_INT", "VISIBLE_HEX"): - sym = c[sym_name] - verify(sym.is_modifiable(), - "{} should be modifiable".format(sym_name)) - - for sym_name in ("n", "m", "y", "NOT_VISIBLE", "SELECTED_TO_Y", - "BOOL_SELECTED_TO_M", "M_VISIBLE_TRISTATE_SELECTED_TO_M", - "NOT_VISIBLE_STRING", "NOT_VISIBLE_INT", "NOT_VISIBLE_HEX"): - sym = c[sym_name] - verify(not sym.is_modifiable(), - "{} should not be modifiable".format(sym_name)) - - # - # get_lower/upper_bound() and get_assignable_values() - # - - c = kconfiglib.Config("Kconfiglib/tests/Kbounds") - - def verify_bounds(sym_name, low, high): - sym = c[sym_name] - sym_low = sym.get_lower_bound() - sym_high = sym.get_upper_bound() - verify(sym_low == low and sym_high == high, - "Incorrectly calculated bounds for {}: {}-{}. " - "Expected {}-{}.".format(sym_name, sym_low, sym_high, - low, high)) - # See that we get back the corresponding range from - # get_assignable_values() - if sym_low is None: - vals = sym.get_assignable_values() - verify(vals == [], - "get_assignable_values() thinks there should be assignable " - "values for {} ({}) but not get_lower/upper_bound()". - format(sym_name, vals)) - if sym.get_type() in (kconfiglib.BOOL, kconfiglib.TRISTATE): - verify(not sym.is_modifiable(), - "get_lower_bound() thinks there should be no " - "assignable values for the bool/tristate {} but " - "is_modifiable() thinks it should be modifiable". - format(sym_name)) - else: - tri_to_int = { "n" : 0, "m" : 1, "y" : 2 } - bound_range = ["n", "m", "y"][tri_to_int[sym_low] : - tri_to_int[sym_high] + 1] - assignable_range = sym.get_assignable_values() - verify(bound_range == assignable_range, - "get_lower/upper_bound() thinks the range for {} should " - "be {} while get_assignable_values() thinks it should be " - "{}".format(sym_name, bound_range, assignable_range)) - if sym.get_type() in (kconfiglib.BOOL, kconfiglib.TRISTATE): - verify(sym.is_modifiable(), - "get_lower/upper_bound() thinks the range for the " - "bool/tristate {} should be {} while is_modifiable() " - "thinks the symbol should not be modifiable". - format(sym_name, bound_range)) - - verify_bounds("n", None, None) - verify_bounds("m", None, None) - verify_bounds("y", None, None) - verify_bounds("Y_VISIBLE_BOOL", "n", "y") - verify_bounds("Y_VISIBLE_TRISTATE", "n", "y") - verify_bounds("M_VISIBLE_BOOL", "n", "y") - verify_bounds("M_VISIBLE_TRISTATE", "n", "m") - verify_bounds("Y_SELECTED_BOOL", None, None) - verify_bounds("M_SELECTED_BOOL", None, None) - verify_bounds("Y_SELECTED_TRISTATE", None, None) - verify_bounds("M_SELECTED_TRISTATE", "m", "y") - verify_bounds("M_SELECTED_M_VISIBLE_TRISTATE", None, None) - verify_bounds("N_IMPLIED_BOOL", "n", "y") - verify_bounds("N_IMPLIED_TRISTATE", "n", "y") - verify_bounds("M_IMPLIED_BOOL", "n", "y") - verify_bounds("M_IMPLIED_TRISTATE", "n", "y") - verify_bounds("Y_IMPLIED_BOOL", "n", "y") - verify_bounds("Y_IMPLIED_TRISTATE", "n", "y") - verify_bounds("STRING", None, None) - verify_bounds("INT", None, None) - verify_bounds("HEX", None, None) + # TODO: Kmodifiable gone, test assignable - # - # eval() - # - print("Testing eval()...") + print("Testing expression evaluation") c = kconfiglib.Config("Kconfiglib/tests/Keval") def verify_eval(expr, val): - res = c.eval(expr) + res = c.eval_string(expr) verify(res == val, "'{}' evaluated to {}, expected {}".format(expr, res, val)) - def verify_eval_bad(expr): - try: - c.eval(expr) - except kconfiglib.Kconfig_Syntax_Error: - pass - else: - fail('eval("{}") should throw Kconfig_Syntax_Error' - .format(expr)) - # No modules verify_eval("n", "n") verify_eval("m", "n") @@ -352,8 +330,9 @@ def run_selftests(): verify_eval("'m'", "n") verify_eval("'y'", "y") verify_eval("M", "y") + # Modules - c["MODULES"].set_user_value("y") + c.syms["MODULES"].set_value("y") verify_eval("n", "n") verify_eval("m", "m") verify_eval("y", "y") @@ -370,6 +349,7 @@ def run_selftests(): # As are all constants besides "y" and "m" verify_eval('"foo"', "n") verify_eval('"foo" || "bar"', "n") + verify_eval('"foo" || m', "m") # Test equality for symbols @@ -398,7 +378,6 @@ def run_selftests(): verify_eval("N != Y", "y") verify_eval("M != Y", "y") - # string/int/hex verify_eval("Y_STRING = y", "y") verify_eval("Y_STRING = 'y'", "y") verify_eval('FOO_BAR_STRING = "foo bar"', "y") @@ -413,12 +392,13 @@ def run_selftests(): verify_eval("HEX_0X37 = '0x037'", "y") verify_eval("HEX_0X37 = '0x0037'", "y") - # Compare some constants... + # Constant symbol comparisons verify_eval('"foo" != "bar"', "y") verify_eval('"foo" = "bar"', "n") verify_eval('"foo" = "foo"', "y") + # Undefined symbols get their name as their value - c.set_print_warnings(False) + c.disable_warnings() verify_eval("'not_defined' = not_defined", "y") verify_eval("not_defined_2 = not_defined_2", "y") verify_eval("not_defined_1 != not_defined_2", "y") @@ -505,9 +485,18 @@ def run_selftests(): verify_eval("oops > INT_37", "n") verify_eval("oops >= INT_37", "n") + def verify_eval_bad(expr): + try: + c.eval_string(expr) + except kconfiglib.KconfigSyntaxError: + pass + else: + fail('expected eval_string("{}") to throw KconfigSyntaxError, ' \ + 'didn\'t'.format(expr)) + # The C implementation's parser can be pretty lax about syntax. Kconfiglib # sometimes needs to emulate that. Verify that some bad stuff throws - # Kconfig_Syntax_Error at least. + # KconfigSyntaxError at least. verify_eval_bad("") verify_eval_bad("&") verify_eval_bad("|") @@ -521,641 +510,498 @@ def run_selftests(): verify_eval_bad("X ||") verify_eval_bad("|| X") - # - # Text queries - # - print("Testing text queries...") + print("Testing Symbol.__str__()") + + def verify_str(item, s): + verify_equal(str(item), s[1:]) + + c = kconfiglib.Config("Kconfiglib/tests/Kstr", warn=False) + + verify_str(c.syms["UNDEFINED"], """ +""") + + verify_str(c.syms["BASIC_NO_PROMPT"], """ +config BASIC_NO_PROMPT + bool + help + blah blah + + blah blah blah + + blah +""") + + verify_str(c.syms["BASIC_PROMPT"], """ +config BASIC_PROMPT + bool + prompt "basic" +""") + + verify_str(c.syms["ADVANCED"], """ +config ADVANCED + tristate + prompt "prompt" if DEP + default DEFAULT_1 + default DEFAULT_2 if DEP + select SELECTED_1 + select SELECTED_2 if DEP + imply IMPLIED_1 + imply IMPLIED_2 if DEP + help + first help text + +config ADVANCED + prompt "prompt 2" + +menuconfig ADVANCED + prompt "prompt 3" if DEP2 + +config ADVANCED + help + second help text +""") + + verify_str(c.syms["STRING"], """ +config STRING + string + default "foo" + default "bar" if DEP + default STRING2 + default STRING3 if DEP +""") + + verify_str(c.syms["INT"], """ +config INT + int + range 1 2 + range FOO BAR + range BAZ QAZ if DEP +""") - def verify_print(o, s): - verify_equals(str(o), textwrap.dedent(s[1:])) + # We still hardcode the modules symbol. Otherwise OPTIONS would have made + # more sense as a name here. + verify_str(c.syms["MODULES"], """ +config MODULES + option modules +""") - for var in ("ARCH", "SRCARCH", "srctree"): - os.environ.pop(var, None) + verify_str(c.syms["OPTIONS"], """ +config OPTIONS + option allnoconfig_y + option defconfig_list + option env="ENV" +""") - # The tests below aren't meant to imply that the format is set in stone. - # It's just to verify that the strings do not change unexpectedly. + print("Testing Choice.__str__()") - # Printing of Config + verify_str(c.named_choices["CHOICE"], """ +choice CHOICE + tristate + prompt "foo" + default CHOICE_1 + default CHOICE_2 if dep +""") - c = kconfiglib.Config("Kconfiglib/tests/Ktext") + verify_str(c.named_choices["CHOICE"].nodes[0].next.item, """ +choice + tristate + prompt "no name" +""") - verify_print(c, """ - Configuration - File : Kconfiglib/tests/Ktext - Base directory : . - Value of $ARCH at creation time : (not set) - Value of $SRCARCH at creation time : (not set) - Value of $srctree at creation time : (not set) - Most recently loaded .config : (no .config loaded) - Print warnings : True - Print assignments to undefined symbols : False""") - os.environ["ARCH"] = "foo" - os.environ["SRCARCH"] = "bar" - os.environ["srctree"] = "baz" + print("Testing Symbol.__repr__()") + + def verify_repr(item, s): + verify_equal(repr(item) + "\n", s[1:]) + + c = kconfiglib.Config("Kconfiglib/tests/Krepr", warn=False) + + verify_repr(c.syms["UNDEFINED"], """ +<symbol UNDEFINED, unknown, value "UNDEFINED", visibility n, direct deps n, 0 menu nodes> +""") + + verify_repr(c.syms["BASIC"], """ +<symbol BASIC, bool, value "y", visibility n, direct deps y, 1 menu node> +""") - c = kconfiglib.Config("Kconfiglib/tests/Ktext", base_dir="foobar") - c.load_config("Kconfiglib/tests/empty") - c.set_print_warnings(False) - c.set_print_undef_assign(True) - - choice_print, choice_no_help, choice_empty_help, choice_help = \ - c.get_choices() - - verify_print(c, """ - Configuration - File : Kconfiglib/tests/Ktext - Base directory : foobar - Value of $ARCH at creation time : foo - Value of $SRCARCH at creation time : bar - Value of $srctree at creation time : baz - Most recently loaded .config : Kconfiglib/tests/empty - Print warnings : False - Print assignments to undefined symbols : True""") - - # Printing of Symbol - - verify_print(c["BASIC"], """ - Symbol BASIC - Type : bool - Value : "n" - User value : (no user value) - Visibility : "n" - Is choice item : False - Is defined : True - Is from env. : False - Is special : False - Prompts: - (no prompts) - Default values: - (no default values) - Selects: - (no selects) - Implies: - (no implies) - Reverse (select-related) dependencies: - (no reverse dependencies) - Weak reverse (imply-related) dependencies: - (no weak reverse dependencies) - Additional dependencies from enclosing menus and ifs: - (no additional dependencies) - Locations: Kconfiglib/tests/Ktext:1""") - - c["ADVANCED"].set_user_value("m") - - verify_print(c["ADVANCED"], """ - Symbol ADVANCED - Type : tristate - Value : "y" - User value : "m" - Visibility : "y" - Is choice item : False - Is defined : True - Is from env. : False - Is special : False - Prompts: - "advanced prompt 1" if y || BASIC && BASIC (value: "y") - "advanced prompt 2" - Default values: - y (value: "y") - Condition: BASIC && !BASIC (value: "n") - n (value: "n") - Condition: BASIC = DUMMY && X < Y && X <= Y && X > Y && X >= Y (value: "n") - Selects: - SELECTED_1 if BASIC && DUMMY (value: "n") - SELECTED_2 if !(DUMMY || BASIC) (value: "y") - Implies: - IMPLIED_1 if BASIC || DUMMY (value: "n") - IMPLIED_2 if !(DUMMY && BASIC) (value: "y") - Reverse (select-related) dependencies: - SELECTING_1 && BASIC || SELECTING_2 && !BASIC (value: "n") - Weak reverse (imply-related) dependencies: - IMPLYING_1 && DUMMY || IMPLYING_2 && !DUMMY (value: "n") - Additional dependencies from enclosing menus and ifs: - !BASIC && !BASIC (value: "y") - Locations: Kconfiglib/tests/Ktext:6 Kconfiglib/tests/Ktext:15""") - - verify_print(c["STRING"], """ - Symbol STRING - Type : string - Value : "foo" - User value : (no user value) - Visibility : "n" - Is choice item : False - Is defined : True - Is from env. : False - Is special : False - Prompts: - (no prompts) - Default values: - "foo" - Condition: (none) - "bar" - Condition: BAR (value: "n") - STRING2 (value: "baz") - Condition: BAZ (value: "n") - Selects: - (no selects) - Implies: - (no implies) - Reverse (select-related) dependencies: - (no reverse dependencies) - Weak reverse (imply-related) dependencies: - (no weak reverse dependencies) - Additional dependencies from enclosing menus and ifs: - !BASIC && !BASIC (value: "y") - Locations: Kconfiglib/tests/Ktext:18""") - - verify_print(c["HAS_RANGES"], """ - Symbol HAS_RANGES - Type : int - Value : "1" - User value : (no user value) - Visibility : "y" - Is choice item : False - Is defined : True - Is from env. : False - Is special : False - Ranges: - [1, 2] if !DUMMY (value: "y") - [INT, INT] if DUMMY (value: "n") - [123, 456] - Prompts: - "ranged" - Default values: - (no default values) - Selects: - (no selects) - Implies: - (no implies) - Reverse (select-related) dependencies: - (no reverse dependencies) - Weak reverse (imply-related) dependencies: - (no weak reverse dependencies) - Additional dependencies from enclosing menus and ifs: - (no additional dependencies) - Locations: Kconfiglib/tests/Ktext:45""") - - # Printing of Choice - - verify_print(choice_print, """ - Choice - Name (for named choices): (no name) - Type : bool - Selected symbol : CHOICE_ITEM_1 - User value : (no user value) - Mode : "y" - Visibility : "y" - Optional : False - Prompts: - "choice" - Defaults: - (no default values) - Choice symbols: - CHOICE_ITEM_1 CHOICE_ITEM_2 CHOICE_ITEM_3 - Additional dependencies from enclosing menus and ifs: - (no additional dependencies) - Locations: Kconfiglib/tests/Ktext:51""") - - c["CHOICE_ITEM_2"].set_user_value("y") - - verify_print(choice_print, """ - Choice - Name (for named choices): (no name) - Type : bool - Selected symbol : CHOICE_ITEM_2 - User value : CHOICE_ITEM_2 - Mode : "y" - Visibility : "y" - Optional : False - Prompts: - "choice" - Defaults: - (no default values) - Choice symbols: - CHOICE_ITEM_1 CHOICE_ITEM_2 CHOICE_ITEM_3 - Additional dependencies from enclosing menus and ifs: - (no additional dependencies) - Locations: Kconfiglib/tests/Ktext:51""") - - # Printing of Menu - - verify_print(c.get_menus()[0], """ - Menu - Title : simple menu - 'depends on' dependencies : (no dependencies) - 'visible if' dependencies : (no dependencies) - Additional dependencies from enclosing menus and ifs: - (no additional dependencies) - Location: Kconfiglib/tests/Ktext:63""") - - verify_print(c.get_menus()[1], """ - Menu - Title : advanced menu - 'depends on' dependencies : !BASIC (value: "y") - 'visible if' dependencies : !DUMMY (value: "y") - Additional dependencies from enclosing menus and ifs: - !DUMMY (value: "y") - Location: Kconfiglib/tests/Ktext:67""") - - # Printing of Comment - - verify_print(c.get_comments()[0], """ - Comment - Text: simple comment - Dependencies: (no dependencies) - Additional dependencies from enclosing menus and ifs: - (no additional dependencies) - Location: Kconfiglib/tests/Ktext:73""") - - verify_print(c.get_comments()[1], """ - Comment - Text: advanced comment - Dependencies: !BASIC (value: "y") - Additional dependencies from enclosing menus and ifs: - !DUMMY (value: "y") - Location: Kconfiglib/tests/Ktext:76""") - - verify_equals(c["NO_HELP"].get_help(), None) - verify_equals(choice_no_help.get_help(), None) - verify_equals(c["EMPTY_HELP"].get_help(), "") - verify_equals(choice_empty_help.get_help(), "") - verify_equals(c["HELP_TERMINATED_BY_COMMENT"].get_help(), "a\nb\nc\n") - verify_equals(c["TRICKY_HELP"].get_help(), - "a\n b\n c\n\n d\n e\n f\n\n\ng\n h\n i\n") - verify_equals(c["S"].get_help(), "help for\nS\n") - verify_equals(choice_help.get_help(), "help for\nC\n") - - verify_equals(c["S"].get_name(), "S") - verify_equals(c.get_comments()[2].get_text(), "a comment") - verify_equals(c.get_menus()[2].get_title(), "a menu") + verify_repr(c.syms["VISIBLE"], """ +<symbol VISIBLE, bool, value "n", visibility y, direct deps y, 1 menu node> +""") - # - # Prompt queries - # + verify_repr(c.syms["DIR_DEP_N"], """ +<symbol DIR_DEP_N, unknown, value "DIR_DEP_N", visibility n, direct deps n, 1 menu node> +""") - print("Testing prompt queries...") + verify_repr(c.syms["OPTIONS"], """ +<symbol OPTIONS, unknown, value "OPTIONS", visibility n, allnoconfig_y, is the defconfig_list symbol, from environment variable ENV, direct deps y, 1 menu node> +""") - def verify_prompts(sym_or_choice, prompts): - sym_or_choice_prompts = sym_or_choice.get_prompts() - verify(len(sym_or_choice_prompts) == len(prompts), - "Wrong number of prompts for " + sym_or_choice.get_name()) - for i in range(0, len(sym_or_choice_prompts)): - verify(sym_or_choice_prompts[i] == prompts[i], - "Prompt {} wrong for {}: Was '{}', should be '{}'". - format(i, sym_or_choice.get_name(), sym_or_choice_prompts[i], - prompts[i])) + verify_repr(c.syms["MULTI_DEF"], """ +<symbol MULTI_DEF, unknown, value "MULTI_DEF", visibility n, direct deps y, 2 menu nodes> +""") - def verify_sym_prompts(sym_name, *prompts): - verify_prompts(c[sym_name], prompts) + verify_repr(c.syms["CHOICE_1"], """ +<symbol CHOICE_1, tristate, value "n", visibility y, choice symbol, direct deps y, 1 menu node> +""") - def verify_choice_prompts(choice, *prompts): - verify_prompts(choice, prompts) + verify_repr(c.syms["MODULES"], """ +<symbol MODULES, bool, value "y", visibility n, is the modules symbol, direct deps y, 1 menu node> +""") - c = kconfiglib.Config("Kconfiglib/tests/Kprompt") - # Symbols - verify_sym_prompts("NO_PROMPT") - verify_sym_prompts("SINGLE_PROMPT_1", "single prompt 1") - verify_sym_prompts("SINGLE_PROMPT_2", "single prompt 2") - verify_sym_prompts("MULTI_PROMPT", "prompt 1", "prompt 2", "prompt 3", "prompt 4") - no_prompt_choice, single_prompt_1_choice, single_prompt_2_choice, multi_prompt_choice = \ - c.get_choices() + print("Testing Choice.__repr__()") - # Choices - verify_choice_prompts(no_prompt_choice) - verify_choice_prompts(single_prompt_1_choice, "single prompt 1 choice") - verify_choice_prompts(single_prompt_2_choice, "single prompt 2 choice") - verify_choice_prompts(multi_prompt_choice, - "prompt 1 choice", "prompt 2 choice", "prompt 3 choice") + verify_repr(c.named_choices["CHOICE"], """ +<choice CHOICE, tristate, mode m, visibility y, 1 menu node> +""") - # - # Location queries - # + c.named_choices["CHOICE"].set_value("y") + + verify_repr(c.named_choices["CHOICE"], """ +<choice CHOICE, tristate, mode y, visibility y, CHOICE_1 selected, 1 menu node> +""") + + c.syms["CHOICE_2"].set_value("y") + + verify_repr(c.named_choices["CHOICE"], """ +<choice CHOICE, tristate, mode y, visibility y, CHOICE_2 selected, 1 menu node> +""") + + verify_repr(c.syms["CHOICE_HOOK"].nodes[0].next.item, """ +<choice, tristate, mode n, visibility n, optional, 1 menu node> +""") + + + print("Testing MenuNode.__repr__()") + + verify_repr(c.syms["BASIC"].nodes[0], """ +<menu node for symbol BASIC, Kconfiglib/tests/Krepr:9, deps y, has help, has next> +""") + + verify_repr(c.syms["DIR_DEP_N"].nodes[0], """ +<menu node for symbol DIR_DEP_N, Kconfiglib/tests/Krepr:17, deps n, has next> +""") + + verify_repr(c.syms["MULTI_DEF"].nodes[0], """ +<menu node for symbol MULTI_DEF, Kconfiglib/tests/Krepr:25, deps y, has next> +""") + + verify_repr(c.syms["MULTI_DEF"].nodes[1], """ +<menu node for symbol MULTI_DEF, Kconfiglib/tests/Krepr:26, deps y, has next> +""") + + verify_repr(c.syms["MENUCONFIG"].nodes[0], """ +<menu node for symbol MENUCONFIG, Kconfiglib/tests/Krepr:28, is menuconfig, deps y, has next> +""") + + verify_repr(c.named_choices["CHOICE"].nodes[0], """ +<menu node for choice CHOICE, Kconfiglib/tests/Krepr:30, prompt "choice" (visibility y), deps y, has child, has next> +""") + + verify_repr(c.syms["CHOICE_HOOK"].nodes[0].next, """ +<menu node for choice, Kconfiglib/tests/Krepr:43, prompt "choice" (visibility n), deps y, has next> +""") + + verify_repr(c.syms["NO_VISIBLE_IF_HOOK"].nodes[0].next, """ +<menu node for menu, Kconfiglib/tests/Krepr:50, prompt "no visible if" (visibility y), deps y, 'visible if' deps y, has next> +""") + + verify_repr(c.syms["VISIBLE_IF_HOOK"].nodes[0].next, """ +<menu node for menu, Kconfiglib/tests/Krepr:55, prompt "visible if" (visibility y), deps y, 'visible if' deps m, has next> +""") + + verify_repr(c.syms["COMMENT_HOOK"].nodes[0].next, """ +<menu node for comment, Kconfiglib/tests/Krepr:61, prompt "comment" (visibility y), deps y> +""") + + + print("Testing Config.__repr__()") + + verify_repr(c, """ +<configuration with 15 symbols, main menu prompt "Linux Kernel Configuration", srctree not set, config symbol prefix "CONFIG_", warnings disabled, undef. symbol assignment warnings disabled> +""") + + os.environ["srctree"] = "srctree value" + os.environ["CONFIG_"] = "CONFIG_ value" + + c = kconfiglib.Config("Kconfiglib/tests/Krepr", warn=False) + c.enable_warnings() + c.enable_undef_warnings() + + verify_repr(c, """ +<configuration with 15 symbols, main menu prompt "Linux Kernel Configuration", srctree "srctree value", config symbol prefix "CONFIG_ value", warnings enabled, undef. symbol assignment warnings enabled> +""") + + os.environ.pop("srctree", None) + os.environ.pop("CONFIG_", None) + + + print("Testing tricky help strings") + + c = kconfiglib.Config("Kconfiglib/tests/Khelp") + + def verify_help(node, s): + verify_equal(node.help, s[1:]) + + verify_help(c.syms["TWO_HELP_STRINGS"].nodes[0], """ +first help string +""") + + verify_help(c.syms["TWO_HELP_STRINGS"].nodes[1], """ +second help string +""") + + verify_help(c.syms["NO_BLANK_AFTER_HELP"].nodes[0], """ +help for +NO_BLANK_AFTER_HELP +""") + + verify_help(c.named_choices["CHOICE_HELP"].nodes[0], """ +help for +CHOICE_HELP +""") + + verify_help(c.syms["HELP_TERMINATED_BY_COMMENT"].nodes[0], """ +a +b +c +""") + + verify_help(c.syms["TRICKY_HELP"].nodes[0], """ +a + b + c + + d + e + f + + +g + h + i +""") - print("Testing location queries...") - def verify_def_locations(sym_name, *locs): - sym_locs = c[sym_name].get_def_locations() - verify(len(sym_locs) == len(locs), - "Wrong number of def. locations for " + sym_name) - for i in range(0, len(sym_locs)): - verify(sym_locs[i] == locs[i], - "Wrong def. location for {}: Was {}, should be {}". - format(sym_name, sym_locs[i], locs[i])) + print("Testing locations and 'source'") + + def verify_locations(nodes, *expected_locs): + verify(len(nodes) == len(expected_locs), + "Wrong number of locations for " + repr(nodes)) + + for node, expected_loc in zip(nodes, expected_locs): + node_loc = "{}:{}".format(node.filename, node.linenr) + verify(node_loc == expected_loc, + "expected {} to have the location {}, had the location {}" + .format(repr(node), expected_loc, node_loc)) # Expanded in the 'source' statement in Klocation - os.environ["FOO"] = "tests" - - c = kconfiglib.Config("Kconfiglib/tests/Klocation", base_dir="Kconfiglib/") - - verify_def_locations("n") - verify_def_locations("m") - verify_def_locations("y") - - verify_def_locations("A", - ("Kconfiglib/tests/Klocation", 4), - ("Kconfiglib/tests/Klocation", 28), - ("Kconfiglib/tests/Klocation_included", 1), - ("Kconfiglib/tests/Klocation_included", 3)) - verify_def_locations("C", - ("Kconfiglib/tests/Klocation", 18)) - verify_def_locations("M", - ("Kconfiglib/tests/Klocation_included", 6)) - verify_def_locations("N", - ("Kconfiglib/tests/Klocation_included", 19)) - verify_def_locations("O", - ("Kconfiglib/tests/Klocation_included", 21)) - verify_def_locations("NOT_DEFINED") # No locations - - def verify_ref_locations(sym_name, *locs): - sym_locs = c[sym_name].get_ref_locations() - verify(len(sym_locs) == len(locs), - "Wrong number of ref. locations for " + sym_name) - for i in range(0, len(sym_locs)): - verify(sym_locs[i] == locs[i], - "Wrong ref. location for {}: Was {}, should be {}". - format(sym_name, sym_locs[i], locs[i])) - - # Reload without the slash at the end of 'base_dir' to get coverage for - # that as well - c = kconfiglib.Config("Kconfiglib/tests/Klocation", base_dir="Kconfiglib") - - verify_ref_locations("A", - ("Kconfiglib/tests/Klocation", 10), - ("Kconfiglib/tests/Klocation", 12), - ("Kconfiglib/tests/Klocation", 16), - ("Kconfiglib/tests/Klocation", 34), - ("Kconfiglib/tests/Klocation", 35), - ("Kconfiglib/tests/Klocation_included", 7), - ("Kconfiglib/tests/Klocation_included", 8), - ("Kconfiglib/tests/Klocation_included", 9), - ("Kconfiglib/tests/Klocation_included", 12), - ("Kconfiglib/tests/Klocation_included", 13), - ("Kconfiglib/tests/Klocation_included", 14), - ("Kconfiglib/tests/Klocation_included", 15), - ("Kconfiglib/tests/Klocation_included", 35), - ("Kconfiglib/tests/Klocation_included", 40), - ("Kconfiglib/tests/Klocation", 65), - ("Kconfiglib/tests/Klocation", 66), - ("Kconfiglib/tests/Klocation", 67), - ("Kconfiglib/tests/Klocation", 68), - ("Kconfiglib/tests/Klocation", 69), - ("Kconfiglib/tests/Klocation", 70), - ("Kconfiglib/tests/Klocation", 71), - ("Kconfiglib/tests/Klocation", 72), - ("Kconfiglib/tests/Klocation", 73)) - verify_ref_locations("C") - verify_ref_locations("NOT_DEFINED", - ("Kconfiglib/tests/Klocation", 12), - ("Kconfiglib/tests/Klocation", 29), - ("Kconfiglib/tests/Klocation_included", 12), - ("Kconfiglib/tests/Klocation_included", 35), - ("Kconfiglib/tests/Klocation_included", 41)) - - # Location queries for choices - - def verify_choice_locations(choice, *locs): - choice_locs = choice.get_def_locations() - verify(len(choice_locs) == len(locs), - "Wrong number of def. locations for choice") - for i in range(0, len(choice_locs)): - verify(choice_locs[i] == locs[i], - "Wrong def. location for choice: Was {}, should be {}". - format(choice_locs[i], locs[i])) - - choice_1, choice_2 = c.get_choices() - - # Throw in named choice test - verify(choice_1.get_name() == "B", - "The first choice should be called B") - verify(choice_2.get_name() is None, - "The second choice should have no name") - - verify_choice_locations(choice_1, - ("Kconfiglib/tests/Klocation", 15), - ("Kconfiglib/tests/Klocation_included", 24)) - verify_choice_locations(choice_2, - ("Kconfiglib/tests/Klocation_included", 17)) - - # Location queries for menus and comments - - def verify_location(menu_or_comment, loc): - menu_or_comment_loc = menu_or_comment.get_location() - verify(menu_or_comment_loc == loc, - "Wrong location for {} with text '{}': Was {}, should be " - "{}".format("menu" if menu_or_comment.is_menu() else "comment", - menu_or_comment.get_title() if - menu_or_comment.is_menu() else - menu_or_comment.get_text(), - menu_or_comment_loc, - loc)) - - menu_1, menu_2 = c.get_menus()[:-1] - comment_1, comment_2 = c.get_comments() - - verify_location(menu_1, ("Kconfiglib/tests/Klocation", 9)) - verify_location(menu_2, ("Kconfiglib/tests/Klocation_included", 5)) - verify_location(comment_1, ("Kconfiglib/tests/Klocation", 31)) - verify_location(comment_2, ("Kconfiglib/tests/Klocation_included", 36)) + os.environ["EXPANDED_FROM_ENV"] = "tests" + os.environ["srctree"] = "Kconfiglib/" - # - # Visibility queries - # + c = kconfiglib.Config("tests/Klocation") - print("Testing visibility queries...") + os.environ.pop("EXPANDED_FROM_ENV", None) + os.environ.pop("srctree", None) - c = kconfiglib.Config("Kconfiglib/tests/Kvisibility") + verify_locations(c.syms["SINGLE_DEF"].nodes, "tests/Klocation:4") + + verify_locations(c.syms["MULTI_DEF"].nodes, + "tests/Klocation:6", + "tests/Klocation:16", + "tests/Klocation_included:3") - def verify_sym_visibility(sym_name, no_module_vis, module_vis): - sym = c[sym_name] + verify_locations(c.named_choices["CHOICE"].nodes, + "tests/Klocation_included:5") + + verify_locations([c.syms["MENU_HOOK"].nodes[0].next], + "tests/Klocation_included:10") + + verify_locations([c.syms["COMMENT_HOOK"].nodes[0].next], + "tests/Klocation_included:15") + + + print("Testing visibility") + + c = kconfiglib.Config("Kconfiglib/tests/Kvisibility") - c["MODULES"].set_user_value("n") - sym_vis = sym.get_visibility() - verify(sym_vis == no_module_vis, - "{} should have visibility '{}' without modules, had " - "visibility '{}'". - format(sym_name, no_module_vis, sym_vis)) + def verify_visibility(item, no_module_vis, module_vis): + c.syms["MODULES"].set_value("n") + verify(item.visibility == no_module_vis, + "expected {} to have visibility {} without modules, had " + "visibility {}". + format(repr(item), no_module_vis, item.visibility)) - c["MODULES"].set_user_value("y") - sym_vis = sym.get_visibility() - verify(sym_vis == module_vis, - "{} should have visibility '{}' with modules, had " - "visibility '{}'". - format(sym_name, module_vis, sym_vis)) + c.syms["MODULES"].set_value("y") + verify(item.visibility == module_vis, + "expected {} to have visibility {} with modules, had " + "visibility {}". + format(repr(item), module_vis, item.visibility)) # Symbol visibility - verify_sym_visibility("NO_PROMPT", "n", "n") - verify_sym_visibility("BOOL_n", "n", "n") - verify_sym_visibility("BOOL_m", "n", "y") # Promoted - verify_sym_visibility("BOOL_MOD", "y", "y") # Promoted - verify_sym_visibility("BOOL_y", "y", "y") - verify_sym_visibility("TRISTATE_m", "n", "m") - verify_sym_visibility("TRISTATE_MOD", "y", "m") # Promoted - verify_sym_visibility("TRISTATE_y", "y", "y") - verify_sym_visibility("BOOL_if_n", "n", "n") - verify_sym_visibility("BOOL_if_m", "n", "y") # Promoted - verify_sym_visibility("BOOL_if_y", "y", "y") - verify_sym_visibility("BOOL_menu_n", "n", "n") - verify_sym_visibility("BOOL_menu_m", "n", "y") # Promoted - verify_sym_visibility("BOOL_menu_y", "y", "y") - verify_sym_visibility("BOOL_choice_n", "n", "n") + verify_visibility(c.syms["NO_PROMPT"], "n", "n") + verify_visibility(c.syms["BOOL_N"], "n", "n") + verify_visibility(c.syms["BOOL_M"], "n", "y") + verify_visibility(c.syms["BOOL_MOD"], "y", "y") + verify_visibility(c.syms["BOOL_Y"], "y", "y") + verify_visibility(c.syms["TRISTATE_M"], "n", "m") + verify_visibility(c.syms["TRISTATE_MOD"], "y", "m") + verify_visibility(c.syms["TRISTATE_Y"], "y", "y") + verify_visibility(c.syms["BOOL_IF_N"], "n", "n") + verify_visibility(c.syms["BOOL_IF_M"], "n", "y") + verify_visibility(c.syms["BOOL_IF_Y"], "y", "y") + verify_visibility(c.syms["BOOL_MENU_N"], "n", "n") + verify_visibility(c.syms["BOOL_MENU_M"], "n", "y") + verify_visibility(c.syms["BOOL_MENU_Y"], "y", "y") + verify_visibility(c.syms["BOOL_CHOICE_N"], "n", "n") # Non-tristate symbols in tristate choices are only visible if the choice # is in "y" mode - verify_sym_visibility("BOOL_choice_m", "n", "n") - verify_sym_visibility("BOOL_choice_y", "y", "n") - c["TRISTATE_choice_m"].set_user_value("y") - c["TRISTATE_choice_y"].set_user_value("y") - # Still limited by the visibility of the choice - verify_sym_visibility("BOOL_choice_m", "n", "n") - # This one should become visible now though - verify_sym_visibility("BOOL_choice_y", "y", "y") - - verify_sym_visibility("TRISTATE_if_n", "n", "n") - verify_sym_visibility("TRISTATE_if_m", "n", "m") - verify_sym_visibility("TRISTATE_if_y", "y", "y") - verify_sym_visibility("TRISTATE_menu_n", "n", "n") - verify_sym_visibility("TRISTATE_menu_m", "n", "m") - verify_sym_visibility("TRISTATE_menu_y", "y", "y") - verify_sym_visibility("TRISTATE_choice_n", "n", "n") - verify_sym_visibility("TRISTATE_choice_m", "n", "m") - verify_sym_visibility("TRISTATE_choice_y", "y", "y") - - # Choice visibility - - def verify_choice_visibility(choice, no_module_vis, module_vis): - c["MODULES"].set_user_value("n") - choice_vis = choice.get_visibility() - verify(choice_vis == no_module_vis, - "choice {} should have visibility '{}' without modules, " - "has visibility '{}'". - format(choice.get_name(), no_module_vis, choice_vis)) - - c["MODULES"].set_user_value("y") - choice_vis = choice.get_visibility() - verify(choice_vis == module_vis, - "choice {} should have visibility '{}' with modules, " - "has visibility '{}'". - format(choice.get_name(), module_vis, choice_vis)) + verify_visibility(c.syms["BOOL_CHOICE_M"], "n", "n") - choice_bool_n, choice_bool_m, choice_bool_y, choice_tristate_n, \ - choice_tristate_m, choice_tristate_y, choice_tristate_if_m_and_y, \ - choice_tristate_menu_n_and_y \ - = c.get_choices()[3:] + # Tristate choices start out in "m" mode. When running without modules, + # their type gets adjusted to bool. + verify_visibility(c.syms["BOOL_CHOICE_Y"], "y", "n") - verify_choice_visibility(choice_bool_n, "n", "n") - verify_choice_visibility(choice_bool_m, "n", "y") # Promoted - verify_choice_visibility(choice_bool_y, "y", "y") - verify_choice_visibility(choice_tristate_n, "n", "n") - verify_choice_visibility(choice_tristate_m, "n", "m") - verify_choice_visibility(choice_tristate_y, "y", "y") + c.syms["TRISTATE_CHOICE_M"].set_value("y") + c.syms["TRISTATE_CHOICE_Y"].set_value("y") - verify_choice_visibility(choice_tristate_if_m_and_y, "n", "m") - verify_choice_visibility(choice_tristate_menu_n_and_y, "n", "n") + # Still limited by the visibility of the choice + verify_visibility(c.syms["BOOL_CHOICE_M"], "n", "n") + + # This one should become visible now + verify_visibility(c.syms["BOOL_CHOICE_Y"], "y", "y") + + verify_visibility(c.syms["TRISTATE_IF_N"], "n", "n") + verify_visibility(c.syms["TRISTATE_IF_M"], "n", "m") + verify_visibility(c.syms["TRISTATE_IF_Y"], "y", "y") + verify_visibility(c.syms["TRISTATE_MENU_N"], "n", "n") + verify_visibility(c.syms["TRISTATE_MENU_M"], "n", "m") + verify_visibility(c.syms["TRISTATE_MENU_Y"], "y", "y") + verify_visibility(c.syms["TRISTATE_CHOICE_N"], "n", "n") + verify_visibility(c.syms["TRISTATE_CHOICE_M"], "n", "m") + verify_visibility(c.syms["TRISTATE_CHOICE_Y"], "y", "y") + + verify_visibility(c.named_choices["BOOL_CHOICE_N"], "n", "n") + verify_visibility(c.named_choices["BOOL_CHOICE_M"], "n", "y") + verify_visibility(c.named_choices["BOOL_CHOICE_Y"], "y", "y") + verify_visibility(c.named_choices["TRISTATE_CHOICE_N"], "n", "n") + verify_visibility(c.named_choices["TRISTATE_CHOICE_M"], "n", "m") + verify_visibility(c.named_choices["TRISTATE_CHOICE_Y"], "y", "y") + + verify_visibility(c.named_choices["TRISTATE_CHOICE_IF_M_AND_Y"], + "n", "m") + verify_visibility(c.named_choices["TRISTATE_CHOICE_MENU_N_AND_Y"], + "n", "n") # Menu visibility def verify_menu_visibility(menu, no_module_vis, module_vis): - c["MODULES"].set_user_value("n") - menu_vis = menu.get_visibility() + c["MODULES"].set_value("n") + menu_vis = kconfiglib.eval_expr(menu.node.dep) verify(menu_vis == no_module_vis, "menu \"{}\" should have visibility '{}' without modules, " - "has visibility '{}'". - format(menu.get_title(), no_module_vis, menu_vis)) + "has visibility '{}'" + .format(menu.title, no_module_vis, menu_vis)) - c["MODULES"].set_user_value("y") - menu_vis = menu.get_visibility() + c["MODULES"].set_value("y") + menu_vis = kconfiglib.eval_expr(menu.node.dep) verify(menu_vis == module_vis, "menu \"{}\" should have visibility '{}' with modules, " "has visibility '{}'". - format(menu.get_title(), module_vis, menu_vis)) + format(menu.title, module_vis, menu_vis)) - menu_n, menu_m, menu_y, menu_if_n, menu_if_m, menu_if_y, \ - menu_if_m_and_y = c.get_menus()[4:-5] - verify(menu_n.get_title() == "menu n", "Ops - testing the wrong menus") + # TODO: does this make sense anymore? - verify_menu_visibility(menu_n, "n", "n") - verify_menu_visibility(menu_m, "n", "m") - verify_menu_visibility(menu_y, "y", "y") - verify_menu_visibility(menu_if_n, "n", "n") - verify_menu_visibility(menu_if_m, "n", "m") - verify_menu_visibility(menu_if_y, "y", "y") - verify_menu_visibility(menu_if_m_and_y, "n", "m") + #menu_n, menu_m, menu_y, menu_if_n, menu_if_m, menu_if_y, \ + # menu_if_m_and_y = get_menus(c)[5:-5] + + #verify_menu_visibility(menu_n, "n", "n") + #verify_menu_visibility(menu_m, "n", "m") + #verify_menu_visibility(menu_y, "y", "y") + #verify_menu_visibility(menu_if_n, "n", "n") + #verify_menu_visibility(menu_if_m, "n", "m") + #verify_menu_visibility(menu_if_y, "y", "y") + #verify_menu_visibility(menu_if_m_and_y, "n", "m") # Menu 'visible if' visibility menu_visible_if_n, menu_visible_if_m, menu_visible_if_y, \ - menu_visible_if_m_2 = c.get_menus()[12:] + menu_visible_if_m_2 = get_menus(c)[13:] def verify_visible_if_visibility(menu, no_module_vis, module_vis): - c["MODULES"].set_user_value("n") + c["MODULES"].set_value("n") menu_vis = menu.get_visible_if_visibility() verify(menu_vis == no_module_vis, "menu \"{}\" should have 'visible if' visibility '{}' " "without modules, has 'visible if' visibility '{}'". - format(menu.get_title(), no_module_vis, menu_vis)) + format(menu.title, no_module_vis, menu_vis)) - c["MODULES"].set_user_value("y") + c["MODULES"].set_value("y") menu_vis = menu.get_visible_if_visibility() verify(menu_vis == module_vis, "menu \"{}\" should have 'visible if' visibility '{}' " "with modules, has 'visible if' visibility '{}'". - format(menu.get_title(), module_vis, menu_vis)) + format(menu.title, module_vis, menu_vis)) + + # TODO: verify the visible if stuff after unclassing # Ordinary visibility should not affect 'visible if' visibility - verify_visible_if_visibility(menu_n, "y", "y") - verify_visible_if_visibility(menu_if_n, "y", "y") - verify_visible_if_visibility(menu_m, "y", "y") - verify_visible_if_visibility(menu_if_m, "y", "y") - - verify_visible_if_visibility(menu_visible_if_n, "n", "n") - verify_visible_if_visibility(menu_visible_if_m, "n", "m") - verify_visible_if_visibility(menu_visible_if_y, "y", "y") - verify_visible_if_visibility(menu_visible_if_m_2, "n", "m") - - # Verify that 'visible if' visibility gets propagated to contained symbols - verify_sym_visibility("VISIBLE_IF_n", "n", "n") - verify_sym_visibility("VISIBLE_IF_m", "n", "m") - verify_sym_visibility("VISIBLE_IF_y", "y", "y") - verify_sym_visibility("VISIBLE_IF_m_2", "n", "m") + #verify_visible_if_visibility(menu_n, "y", "y") + #verify_visible_if_visibility(menu_if_n, "y", "y") + #verify_visible_if_visibility(menu_m, "y", "y") + #verify_visible_if_visibility(menu_if_m, "y", "y") + + #verify_visible_if_visibility(menu_visible_if_n, "n", "n") + #verify_visible_if_visibility(menu_visible_if_m, "n", "m") + #verify_visible_if_visibility(menu_visible_if_y, "y", "y") + #verify_visible_if_visibility(menu_visible_if_m_2, "n", "m") + + # Verify that 'visible if' visibility gets propagated to prompts + verify_visibility(c.syms["VISIBLE_IF_N"], "n", "n") + verify_visibility(c.syms["VISIBLE_IF_M"], "n", "m") + verify_visibility(c.syms["VISIBLE_IF_Y"], "y", "y") + verify_visibility(c.syms["VISIBLE_IF_M_2"], "n", "m") # Comment visibility def verify_comment_visibility(comment, no_module_vis, module_vis): - c["MODULES"].set_user_value("n") - comment_vis = comment.get_visibility() + c["MODULES"].set_value("n") + # TODO: uninternalize + comment_vis = kconfiglib.eval_expr(comment.node.dep) verify(comment_vis == no_module_vis, "comment \"{}\" should have visibility '{}' without " "modules, has visibility '{}'". - format(comment.get_text(), no_module_vis, comment_vis)) + format(comment.text, no_module_vis, comment_vis)) - c["MODULES"].set_user_value("y") - comment_vis = comment.get_visibility() + c["MODULES"].set_value("y") + comment_vis = kconfiglib.eval_expr(comment.node.dep) verify(comment_vis == module_vis, "comment \"{}\" should have visibility '{}' with " "modules, has visibility '{}'". - format(comment.get_text(), module_vis, comment_vis)) + format(comment.text, module_vis, comment_vis)) + + # TODO: verify the visibility stuff for comments - comment_n, comment_m, comment_y, comment_if_n, comment_if_m, \ - comment_if_y, comment_m_nested = c.get_comments() + #comment_n, comment_m, comment_y, comment_if_n, comment_if_m, \ + # comment_if_y, comment_m_nested = get_comments(c) - verify_comment_visibility(comment_n, "n", "n") - verify_comment_visibility(comment_m, "n", "m") - verify_comment_visibility(comment_y, "y", "y") - verify_comment_visibility(comment_if_n, "n", "n") - verify_comment_visibility(comment_if_m, "n", "m") - verify_comment_visibility(comment_if_y, "y", "y") - verify_comment_visibility(comment_m_nested, "n", "m") + #verify_comment_visibility(comment_n, "n", "n") + #verify_comment_visibility(comment_m, "n", "m") + #verify_comment_visibility(comment_y, "y", "y") + #verify_comment_visibility(comment_if_n, "n", "n") + #verify_comment_visibility(comment_if_m, "n", "m") + #verify_comment_visibility(comment_if_y, "y", "y") + #verify_comment_visibility(comment_m_nested, "n", "m") # Verify that string/int/hex symbols with m visibility accept a user value - assign_and_verify_new_value("STRING_m", "foo bar", "foo bar") - assign_and_verify_new_value("INT_m", "123", "123") - assign_and_verify_new_value("HEX_m", "0x123", "0x123") + assign_and_verify("STRING_m", "foo bar") + assign_and_verify("INT_m", "123") + assign_and_verify("HEX_m", "0x123") # # Object relations @@ -1163,61 +1009,41 @@ def run_selftests(): c = kconfiglib.Config("Kconfiglib/tests/Krelation") - A, B, C, D, E, F, G, H, I = c["A"], c["B"], c["C"], c["D"], c["E"], c["F"],\ - c["G"], c["H"], c["I"] - choice_1, choice_2 = c.get_choices() - verify([menu.get_title() for menu in c.get_menus()] == - ["m1", "m2", "m3", "m4"], - "menu ordering is broken") - menu_1, menu_2, menu_3, menu_4 = c.get_menus() + UNDEFINED, A, B, C, D, E, F, G, H, I = \ + c.syms["UNDEFINED"], c.syms["A"], c.syms["B"], c.syms["C"], \ + c.syms["D"], c.syms["E"], c.syms["F"], c.syms["G"], c.syms["H"], \ + c.syms["I"] + choice_1, choice_2 = get_choices(c) + + # TODO: test new prompts + #verify([menu.title for menu in get_menus(c)[1:]] == + # ["m1", "m2", "m3", "m4"], + # "menu ordering is broken") + #menu_1, menu_2, menu_3, menu_4 = get_menus(c)[1:] print("Testing object relations...") - verify(A.get_parent() is None, "A should not have a parent") - verify(B.get_parent() is choice_1, "B's parent should be the first choice") - verify(C.get_parent() is choice_1, "C's parent should be the first choice") - verify(E.get_parent() is menu_1, "E's parent should be the first menu") - verify(E.get_parent().get_parent() is None, - "E's grandparent should be None") - verify(G.get_parent() is choice_2, + # TODO: check parents for menus + + verify(get_parent(UNDEFINED) is None, + "Undefined symbols should have no parent") + # TODO: update this test (should be the main menu) + # TODO: test parents when automatic menus are involved + #verify(A.get_parent() is None, "A should not have a parent") + verify(get_parent(B) is choice_1, "B's parent should be the first choice") + # TODO: no longer true due to auto menus + #verify(get_parent(C) is choice_1, "C's parent should be the first choice") + #verify(get_parent(E) is menu_1, "E's parent should be the first menu") + # TODO: update this test + #verify(E.get_parent().get_parent() is None, + # "E's grandparent should be None") + verify(get_parent(G) is choice_2, "G's parent should be the second choice") - verify(G.get_parent().get_parent() is menu_2, - "G's grandparent should be the second menu") - - # - # Object fetching (same test file) - # + #verify(get_parent(get_parent(G)) is menu_2, + # "G's grandparent should be the second menu") - print("Testing object fetching...") - - verify_equals(c.get_symbol("NON_EXISTENT"), None) - verify(c.get_symbol("A") is A, "get_symbol() is broken") - - verify(c.get_top_level_items() == [A, choice_1, menu_1, menu_3, menu_4], - "Wrong items at top level") - verify(c.get_symbols(False) == [A, B, C, D, E, F, G, H, I], - "get_symbols() is broken") - - verify(choice_1.get_items() == [B, C, D], - "Wrong get_items() items in 'choice'") - # Test Kconfig quirk - verify(choice_1.get_symbols() == [B, D], - "Wrong get_symbols() symbols in 'choice'") - - verify(menu_1.get_items() == [E, menu_2, I], "Wrong items in first menu") - verify(menu_1.get_symbols() == [E, I], "Wrong symbols in first menu") - verify(menu_1.get_items(True) == [E, menu_2, F, choice_2, G, H, I], - "Wrong recursive items in first menu") - verify(menu_1.get_symbols(True) == [E, F, G, H, I], - "Wrong recursive symbols in first menu") - verify(menu_2.get_items() == [F, choice_2], - "Wrong items in second menu") - verify(menu_2.get_symbols() == [F], - "Wrong symbols in second menu") - verify(menu_2.get_items(True) == [F, choice_2, G, H], - "Wrong recursive items in second menu") - verify(menu_2.get_symbols(True) == [F, G, H], - "Wrong recursive symbols in second menu") + # TODO: test parents of comments + # TODO: test top node # # hex/int ranges @@ -1227,16 +1053,16 @@ def run_selftests(): c = kconfiglib.Config("Kconfiglib/tests/Krange") - for sym_name in ("HEX_NO_RANGE", "INT_NO_RANGE", "HEX_40", "INT_40"): - sym = c[sym_name] - verify(not sym.has_ranges(), + for sym_name in "HEX_NO_RANGE", "INT_NO_RANGE", "HEX_40", "INT_40": + sym = c.syms[sym_name] + verify(not sym.ranges, "{} should not have ranges".format(sym_name)) - for sym_name in ("HEX_ALL_RANGES_DISABLED", "INT_ALL_RANGES_DISABLED", - "HEX_RANGE_10_20_LOW_DEFAULT", - "INT_RANGE_10_20_LOW_DEFAULT"): - sym = c[sym_name] - verify(sym.has_ranges(), "{} should have ranges".format(sym_name)) + for sym_name in "HEX_ALL_RANGES_DISABLED", "INT_ALL_RANGES_DISABLED", \ + "HEX_RANGE_10_20_LOW_DEFAULT", \ + "INT_RANGE_10_20_LOW_DEFAULT": + sym = c.syms[sym_name] + verify(sym.ranges, "{} should have ranges".format(sym_name)) # hex/int symbols without defaults should get no default value verify_value("HEX_NO_RANGE", "") @@ -1246,9 +1072,9 @@ def run_selftests(): verify_value("INT_ALL_RANGES_DISABLED", "") # Make sure they are assignable though, and test that the form of the user # value is reflected in the value for hex symbols - assign_and_verify_new_value("HEX_NO_RANGE", "0x123", "0x123") - assign_and_verify_new_value("HEX_NO_RANGE", "123", "123") - assign_and_verify_new_value("INT_NO_RANGE", "123", "123") + assign_and_verify("HEX_NO_RANGE", "0x123") + assign_and_verify("HEX_NO_RANGE", "123") + assign_and_verify("INT_NO_RANGE", "123") # Defaults outside of the valid range should be clamped verify_value("HEX_RANGE_10_20_LOW_DEFAULT", "0x10") @@ -1275,13 +1101,13 @@ def run_selftests(): """Tests that the values in the range 'low'-'high' can be assigned, and that assigning values outside this range reverts the value back to 'default' (None if it should revert back to "").""" - is_hex = (c[sym_name].get_type() == kconfiglib.HEX) + is_hex = (c.syms[sym_name].type == kconfiglib.HEX) for i in range(low, high + 1): - assign_and_verify_new_user_value(sym_name, str(i), str(i)) + assign_and_verify_user_value(sym_name, str(i), str(i)) if is_hex: # The form of the user value should be preserved for hex # symbols - assign_and_verify_new_user_value(sym_name, hex(i), hex(i)) + assign_and_verify_user_value(sym_name, hex(i), hex(i)) # Verify that assigning a user value just outside the range causes # defaults to be used @@ -1298,8 +1124,8 @@ def run_selftests(): too_low_str = str(low - 1) too_high_str = str(high + 1) - assign_and_verify_new_value(sym_name, too_low_str, default_str) - assign_and_verify_new_value(sym_name, too_high_str, default_str) + assign_and_verify_value(sym_name, too_low_str, default_str) + assign_and_verify_value(sym_name, too_high_str, default_str) verify_range("HEX_RANGE_10_20_LOW_DEFAULT", 0x10, 0x20, 0x10) verify_range("HEX_RANGE_10_20_HIGH_DEFAULT", 0x10, 0x20, 0x20) @@ -1321,15 +1147,15 @@ def run_selftests(): verify_value("HEX_40", "40") verify_value("INT_40", "40") - c["HEX_RANGE_10_20"].unset_user_value() - c["INT_RANGE_10_20"].unset_user_value() + c.syms["HEX_RANGE_10_20"].unset_value() + c.syms["INT_RANGE_10_20"].unset_value() verify_value("HEX_RANGE_10_40_DEPENDENT", "0x10") verify_value("INT_RANGE_10_40_DEPENDENT", "10") - c["HEX_RANGE_10_20"].set_user_value("15") - c["INT_RANGE_10_20"].set_user_value("15") + c.syms["HEX_RANGE_10_20"].set_value("15") + c.syms["INT_RANGE_10_20"].set_value("15") verify_value("HEX_RANGE_10_40_DEPENDENT", "0x15") verify_value("INT_RANGE_10_40_DEPENDENT", "15") - c.unset_user_values() + c.unset_values() verify_range("HEX_RANGE_10_40_DEPENDENT", 0x10, 0x40, 0x10) verify_range("INT_RANGE_10_40_DEPENDENT", 10, 40, 10) @@ -1338,184 +1164,64 @@ def run_selftests(): verify_value("INACTIVE_RANGE", "2") verify_value("ACTIVE_RANGE", "1") - # - # get_referenced_symbols() - # - - c = kconfiglib.Config("Kconfiglib/tests/Kref") - - # General function for checking get_referenced_symbols() output. - # Specialized for symbols below. - def verify_refs(item, refs_no_enclosing, refs_enclosing): - item_refs = item.get_referenced_symbols() - item_refs_enclosing = item.get_referenced_symbols(True) - - # For failure messages - if item.is_symbol(): - item_string = item.get_name() - elif item.is_choice(): - if item.get_name() is None: - item_string = "choice" - else: - item_string = "choice " + item.get_name() - elif item.is_menu(): - item_string = 'menu "{}"'.format(item.get_title()) - else: - # Comment - item_string = 'comment "{}"'.format(item.get_text()) - - verify(len(item_refs) == len(refs_no_enclosing), - "Wrong number of refs excluding enclosing for {}". - format(item_string)) - verify(len(item_refs_enclosing) == len(refs_enclosing), - "Wrong number of refs including enclosing for {}". - format(item_string)) - for r in [c[name] for name in refs_no_enclosing]: - verify(r in item_refs, - "{} should reference {} when excluding enclosing". - format(item_string, r.get_name())) - for r in [c[name] for name in refs_enclosing]: - verify(r in item_refs_enclosing, - "{} should reference {} when including enclosing". - format(item_string, r.get_name())) - - # Symbols referenced by symbols - - def verify_sym_refs(sym_name, refs_no_enclosing, refs_enclosing): - verify_refs(c[sym_name], refs_no_enclosing, refs_enclosing) - - verify_sym_refs("NO_REF", [], []) - verify_sym_refs("ONE_REF", ["A"], ["A"]) - own_refs = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", - "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", - "Y", "Z", "AA"] - verify_sym_refs("MANY_REF", - own_refs, - own_refs + ["IF_REF_1", "IF_REF_2", "MENU_REF_1", - "MENU_REF_2"]) - - # Symbols referenced by choices - - own_refs = ["CHOICE_REF_4", "CHOICE_REF_5", "CHOICE_REF_6"] - verify_refs(c.get_choices()[0], - own_refs, - own_refs + ["CHOICE_REF_1", "CHOICE_REF_2", "CHOICE_REF_3"]) - - # Symbols referenced by menus - - own_refs = ["NO_REF", "MENU_REF_3"] - verify_refs(c.get_menus()[1], - own_refs, - own_refs + ["MENU_REF_1", "MENU_REF_2"]) - - # Symbols referenced by comments - - own_refs = ["COMMENT_REF_3", "COMMENT_REF_4", "COMMENT_REF_5"] - verify_refs(c.get_comments()[0], - own_refs, - own_refs + ["COMMENT_REF_1", "COMMENT_REF_2"]) - - # - # get_selected_symbols() (same test file) - # - - def verify_selects(sym_name, selection_names): - sym = c[sym_name] - sym_selections = sym.get_selected_symbols() - verify(len(sym_selections) == len(selection_names), - "Wrong number of selects for {}".format(sym_name)) - for sel_name in selection_names: - sel_sym = c[sel_name] - verify(sel_sym in sym_selections, - "{} should be selected by {}".format(sel_name, sym_name)) - - verify_selects("n", []) - verify_selects("m", []) - verify_selects("y", []) - verify_selects("UNAME_RELEASE", []) - - verify_selects("NO_REF", []) - verify_selects("MANY_REF", ["I", "N"]) + # TODO: test symbol references in some other way? + # TODO: test selects in some other way? + # TODO: test implies in some other way? # - # get_implied_symbols() (same test file) + # defconfig_filename # - def verify_implies(sym_name, imply_names): - sym = c[sym_name] - sym_implies = sym.get_implied_symbols() - verify(len(sym_implies) == len(imply_names), - "Wrong number of implies for {}".format(sym_name)) - for imply_name in imply_names: - implied_sym = c[imply_name] - verify(implied_sym in sym_implies, - "{} should be implied by {}".format(imply_name, sym_name)) - - verify_implies("n", []) - verify_implies("m", []) - verify_implies("y", []) - verify_implies("UNAME_RELEASE", []) - - verify_implies("NO_REF", []) - verify_implies("MANY_REF", ["P", "U"]) - - # - # get_defconfig_filename() - # - - print("Testing get_defconfig_filename()...") + print("Testing defconfig_filename...") c = kconfiglib.Config("Kconfiglib/tests/empty") - verify(c.get_defconfig_filename() is None, - "get_defconfig_filename() should be None with no defconfig_list " - "symbol") + verify(c.defconfig_filename is None, + "defconfig_filename should be None with no defconfig_list symbol") c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_nonexistent") - verify(c.get_defconfig_filename() is None, - "get_defconfig_filename() should be None when none of the files " - "in the defconfig_list symbol exist") + verify(c.defconfig_filename is None, + "defconfig_filename should be None when none of the files in the " + "defconfig_list symbol exist") # Referenced in Kdefconfig_existent(_but_n) os.environ["BAR"] = "defconfig_2" c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_existent_but_n") - verify(c.get_defconfig_filename() is None, - "get_defconfig_filename() should be None when the condition is " - "n for all the defaults") + verify(c.defconfig_filename is None, + "defconfig_filename should be None when the condition is n for all " + "the defaults") c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_existent") - verify(c.get_defconfig_filename() == "Kconfiglib/tests/defconfig_2", - "get_defconfig_filename() should return the existent file " + verify(c.defconfig_filename == "Kconfiglib/tests/defconfig_2", + "defconfig_filename should return the existent file " "Kconfiglib/tests/defconfig_2") # Should also look relative to $srctree if the defconfig is an absolute # path and not found - del os.environ["srctree"] c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_srctree") - verify(c.get_defconfig_filename() == "Kconfiglib/tests/defconfig_2", - "get_defconfig_filename() returned wrong file with $srctree unset") + verify(c.defconfig_filename == "Kconfiglib/tests/defconfig_2", + "defconfig_filename gave wrong file with $srctree unset") os.environ["srctree"] = "Kconfiglib/tests" c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_srctree") - verify(c.get_defconfig_filename() == - "Kconfiglib/tests/sub/defconfig_in_sub", - "get_defconfig_filename() returned wrong file with $srctree set") + verify(c.defconfig_filename == "Kconfiglib/tests/sub/defconfig_in_sub", + "defconfig_filename gave wrong file with $srctree set") # - # get_mainmenu_text() + # mainmenu_text # - print("Testing get_mainmenu_text()...") + print("Testing mainmenu_text...") c = kconfiglib.Config("Kconfiglib/tests/empty") - verify(c.get_mainmenu_text() is None, - "An empty Kconfig should not have a mainmenu text") + verify(c.mainmenu_text == "Linux Kernel Configuration", + "An empty Kconfig should get a default main menu prompt") # Expanded in the mainmenu text os.environ["FOO"] = "bar baz" c = kconfiglib.Config("Kconfiglib/tests/Kmainmenu") - verify(c.get_mainmenu_text() == "---bar baz---", + verify(c.mainmenu_text == "---bar baz---", "Wrong mainmenu text") # @@ -1524,134 +1230,95 @@ def run_selftests(): os.environ["ENV_VAR"] = "foo" # Contains reference to undefined environment variable, so disable warnings - c = kconfiglib.Config("Kconfiglib/tests/Kmisc", print_warnings = False) + c = kconfiglib.Config("Kconfiglib/tests/Kmisc", warn = False) - print("Testing is_optional()...") + print("Testing is_optional...") - verify(not c.get_choices()[0].is_optional(), + verify(not get_choices(c)[0].is_optional, "First choice should not be optional") - verify(c.get_choices()[1].is_optional(), + verify(get_choices(c)[1].is_optional, "Second choice should be optional") - print("Testing get_user_value()...") + print("Testing user_value...") # Avoid warnings from assigning invalid user values and assigning user # values to symbols without prompts - c.set_print_warnings(False) + c.disable_warnings() - syms = [c[name] for name in \ + syms = [c.syms[name] for name in \ ("BOOL", "TRISTATE", "STRING", "INT", "HEX")] for sym in syms: - verify(sym.get_user_value() is None, + verify(sym.user_value is None, "{} should not have a user value to begin with") # Assign valid values for the types - assign_and_verify_new_user_value("BOOL", "n", "n") - assign_and_verify_new_user_value("BOOL", "y", "y") - assign_and_verify_new_user_value("TRISTATE", "n", "n") - assign_and_verify_new_user_value("TRISTATE", "m", "m") - assign_and_verify_new_user_value("TRISTATE", "y", "y") - assign_and_verify_new_user_value("STRING", "foo bar", "foo bar") - assign_and_verify_new_user_value("INT", "123", "123") - assign_and_verify_new_user_value("HEX", "0x123", "0x123") + assign_and_verify_user_value("BOOL", "n", "n") + assign_and_verify_user_value("BOOL", "y", "y") + assign_and_verify_user_value("TRISTATE", "n", "n") + assign_and_verify_user_value("TRISTATE", "m", "m") + assign_and_verify_user_value("TRISTATE", "y", "y") + assign_and_verify_user_value("STRING", "foo bar", "foo bar") + assign_and_verify_user_value("INT", "123", "123") + assign_and_verify_user_value("HEX", "0x123", "0x123") # Assign invalid values for the types. They should retain their old user # value. - assign_and_verify_new_user_value("BOOL", "m", "y") - assign_and_verify_new_user_value("BOOL", "foo", "y") - assign_and_verify_new_user_value("BOOL", "1", "y") - assign_and_verify_new_user_value("TRISTATE", "foo", "y") - assign_and_verify_new_user_value("TRISTATE", "1", "y") - assign_and_verify_new_user_value("INT", "foo", "123") - assign_and_verify_new_user_value("HEX", "foo", "0x123") + assign_and_verify_user_value("BOOL", "m", "y") + assign_and_verify_user_value("BOOL", "foo", "y") + assign_and_verify_user_value("BOOL", "1", "y") + assign_and_verify_user_value("TRISTATE", "foo", "y") + assign_and_verify_user_value("TRISTATE", "1", "y") + assign_and_verify_user_value("INT", "foo", "123") + assign_and_verify_user_value("HEX", "foo", "0x123") for s in syms: - s.unset_user_value() - verify(s.get_user_value() is None, + s.unset_value() + verify(s.user_value is None, "{} should not have a user value after being reset". - format(s.get_name())) - - print("Testing is_defined()...") - - for sym_name in ("n", "m", "y", "UNAME_RELEASE", "A", "B", "C", "D", - "BOOL", "TRISTATE", "STRING", "INT", "HEX"): - sym = c[sym_name] - verify(sym.is_defined(), - "{} should be defined".format(sym_name)) - - for sym_name in ("NOT_DEFINED_1", "NOT_DEFINED_2", "NOT_DEFINED_3", - "NOT_DEFINED_4"): - sym = c[sym_name] - verify(not sym.is_defined(), - "{} should not be defined".format(sym_name)) - - print("Testing is_special()...") - - for sym_name in ("n", "m", "y", "UNAME_RELEASE", "FROM_ENV", - "FROM_ENV_MISSING"): - sym = c[sym_name] - verify(sym.is_special(), - "{} should be special".format(sym_name)) - - for sym_name in ("A", "B", "C", "D", "BOOL", "TRISTATE", "STRING", - "INT", "HEX", "NOT_DEFINED_1", "NOT_DEFINED_2", - "NOT_DEFINED_3", "NOT_DEFINED_4"): - sym = c[sym_name] - verify(not sym.is_special(), - "{} should not be special".format(sym_name)) - - print("Testing is_from_environment()...") - - for sym_name in ("FROM_ENV", "FROM_ENV_MISSING"): - sym = c[sym_name] - verify(sym.is_from_environment(), - "{} should be from the environment".format(sym_name)) - - for sym_name in ("n", "m", "y", "UNAME_RELEASE", "A", "B", "C", "D", - "BOOL", "TRISTATE", "STRING", "INT", "HEX", - "NOT_DEFINED_1", "NOT_DEFINED_2", "NOT_DEFINED_3", - "NOT_DEFINED_4"): - sym = c[sym_name] - verify(not sym.is_from_environment(), - "{} should not be from the environment".format(sym_name)) - - print("Testing is_choice_symbol()...") - - for sym_name in ("A", "B", "C", "D"): - sym = c[sym_name] - verify(sym.is_choice_symbol(), - "{} should be a choice symbol".format(sym_name)) - - for sym_name in ("n", "m", "y", "UNAME_RELEASE", "Q1", "Q2", "Q3", "BOOL", - "TRISTATE", "STRING", "INT", "HEX", "FROM_ENV", - "FROM_ENV_MISSING", "NOT_DEFINED_1", "NOT_DEFINED_2", - "NOT_DEFINED_3", "NOT_DEFINED_4"): - sym = c[sym_name] - verify(not sym.is_choice_symbol(), - "{} should not be a choice symbol".format(sym_name)) - - print("Testing is_allnoconfig_y()...") - - verify(not c["NOT_ALLNOCONFIG_Y"].is_allnoconfig_y(), + format(s.name)) + + print("Testing defined vs undefined symbols...") + + for name in "A", "B", "C", "D", "BOOL", "TRISTATE", "STRING", "INT", "HEX": + verify(c.syms[name].nodes, + "{} should be defined".format(name)) + + for name in "NOT_DEFINED_1", "NOT_DEFINED_2", "NOT_DEFINED_3", \ + "NOT_DEFINED_4": + sym = c.syms[name] + verify(not c.syms[name].nodes, + "{} should not be defined".format(name)) + + print("Testing Symbol.choice...") + + for name in "A", "B", "C", "D": + verify(c.syms[name].choice is not None, + "{} should be a choice symbol".format(name)) + + for name in "Q1", "Q2", "Q3", "BOOL", "TRISTATE", "STRING", "INT", "HEX", \ + "FROM_ENV", "FROM_ENV_MISSING", "NOT_DEFINED_1", \ + "NOT_DEFINED_2", "NOT_DEFINED_3", "NOT_DEFINED_4": + verify(c.syms[name].choice is None, + "{} should not be a choice symbol".format(name)) + + print("Testing is_allnoconfig_y...") + + verify(not c.syms["NOT_ALLNOCONFIG_Y"].is_allnoconfig_y, "NOT_ALLNOCONFIG_Y should not be allnoconfig_y") - verify(c["ALLNOCONFIG_Y"].is_allnoconfig_y(), + verify(c.syms["ALLNOCONFIG_Y"].is_allnoconfig_y, "ALLNOCONFIG_Y should be allnoconfig_y") - print("Testing UNAME_RELEASE value...") + print("Testing UNAME_RELEASE...") verify_value("UNAME_RELEASE", platform.uname()[2]) - - # Expansion of environment variables in Config.__init__'s base_dir - # parameter. Just make sure we don't crash when Kbase_dir 'source's a file - # from the same directory. - - os.environ["EnV_VaR1"] = "Kconfigl" - os.environ["EnV_VaR2"] = "ib/tests" - kconfiglib.Config("Kconfiglib/tests/Kbase_dir", - base_dir="$EnV_VaR1$EnV_VaR2/") + ur = c.syms["UNAME_RELEASE"] + verify(ur.config is c and + ur.type == kconfiglib.STRING and + ur.env_var == "<uname release>", + "UNAME_RELEASE has wrong fields") # # .config reading and writing @@ -1664,9 +1331,9 @@ def run_selftests(): def write_and_verify_header(header): c.write_config(config_test_file, header) c.load_config(config_test_file) - verify(c.get_config_header() == header, + verify(c.config_header == header, "The header {} morphed into {} on loading" - .format(repr(header), repr(c.get_config_header()))) + .format(repr(header), repr(c.config_header))) def verify_file_contents(fname, contents): with open(fname, "r") as f: @@ -1680,12 +1347,12 @@ def run_selftests(): c = kconfiglib.Config("Kconfiglib/tests/Kescape") # Test the default value - c.write_config(config_test_file + "_from_def") + c.write_config(config_test_file + "_from_def", header="") verify_file_contents(config_test_file + "_from_def", r'''CONFIG_STRING="\"\\"''' "\n") # Write our own value - c["STRING"].set_user_value(r'''\"a'\\''') - c.write_config(config_test_file + "_from_user") + c.syms["STRING"].set_value(r'''\"a'\\''') + c.write_config(config_test_file + "_from_user", header="") verify_file_contents(config_test_file + "_from_user", r'''CONFIG_STRING="\\\"a'\\\\"''' "\n") @@ -1695,46 +1362,6 @@ def run_selftests(): c.load_config(config_test_file + "_from_user") verify_value("STRING", r'''\"a'\\''') - # Reading and writing of .config headers - - verify(c.get_config_header() is None, - "Expected no header before .config loaded, got '{}'". - format(c.get_config_header())) - - write_and_verify_header("") - write_and_verify_header(" ") - write_and_verify_header("\n") - write_and_verify_header("\n\n") - write_and_verify_header("#") - write_and_verify_header("a") - write_and_verify_header("a\n") - write_and_verify_header("a\n\n") - write_and_verify_header("abcdef") - write_and_verify_header("foo\nbar baz\n\n\n qaz#") - - c.load_config("Kconfiglib/tests/empty") - verify(c.get_config_header() is None, - "Expected no header in empty .config, got '{}'". - format(c.get_config_header())) - - c.load_config("Kconfiglib/tests/config_hash") - verify(c.get_config_header() == "", - "Expected empty header in file with just '#', got '{}'". - format(c.get_config_header())) - - # TODO: Line joining (which stems from _FileFeed reuse) probably doesn't - # make sense within .config files. (The C implementation has no notion of - # continuation lines within .config files.) It's harmless except for fairly - # obscure cases though. - # - # Add a test for now just to get test coverage for _FileFeed.peek_next(), - # which is only used while reading .config files as of writing. - - c.load_config("Kconfiglib/tests/config_continuation") - verify(c.get_config_header() == - " Foo # Bar\n Baz # Foo # Bar\n Baz\n Foo", - "Continuation line handling within .config headers is broken") - # Appending values from a .config c = kconfiglib.Config("Kconfiglib/tests/Kappend") @@ -1767,70 +1394,30 @@ def run_selftests(): verify_value("IGNOREME", "y") # - # get_config() + # .config # - print("Testing get_config()...") + print("Testing .config...") - c1 = kconfiglib.Config("Kconfiglib/tests/Kmisc", print_warnings = False) - c2 = kconfiglib.Config("Kconfiglib/tests/Kmisc", print_warnings = False) + c1 = kconfiglib.Config("Kconfiglib/tests/Kmisc", warn = False) + c2 = kconfiglib.Config("Kconfiglib/tests/Kmisc", warn = False) - c1_bool, c1_choice, c1_menu, c1_comment = c1["BOOL"], \ - c1.get_choices()[0], c1.get_menus()[0], c1.get_comments()[0] - c2_bool, c2_choice, c2_menu, c2_comment = c2["BOOL"], \ - c2.get_choices()[0], c2.get_menus()[0], c2.get_comments()[0] + c1_undef, c1_bool, c1_choice, c1_menu, c1_comment = c1.syms["BOOL"], \ + c1.syms["NOT_DEFINED_1"], get_choices(c1)[0], get_menus(c1)[0], \ + get_comments(c1)[0] + c2_undef, c2_bool, c2_choice, c2_menu, c2_comment = c2.syms["BOOL"], \ + c2.syms["NOT_DEFINED_1"], get_choices(c2)[0], get_menus(c2)[0], \ + get_comments(c2)[0] - verify((c1_bool is not c2_bool) and (c1_choice is not c2_choice) and - (c1_menu is not c2_menu) and (c1_comment is not c2_comment) and - (c1_bool.get_config() is c1) and (c2_bool.get_config() is c2) and - (c1_choice.get_config() is c1) and (c2_choice.get_config() is c2) and - (c1_menu.get_config() is c1) and (c2_menu.get_config() is c2) and - (c1_comment.get_config() is c1) and (c2_comment.get_config() is c2), - "Config instance state separation or get_config() is broken") - - # - # get_arch/srcarch/srctree/kconfig_filename() - # - - del os.environ["ARCH"] - del os.environ["SRCARCH"] - del os.environ["srctree"] - - c = kconfiglib.Config("Kconfiglib/tests/Kmisc", print_warnings = False) - arch = c.get_arch() - verify(arch is None, "Expected None arch, got '{}'".format(arch)) - srcarch = c.get_srcarch() - verify(srcarch is None, "Expected None srcarch, got '{}'".format(srcarch)) - srctree = c.get_srctree() - verify(srctree is None, "Expected None srctree, got '{}'".format(srctree)) - - os.environ["ARCH"] = "ARCH value" - os.environ["SRCARCH"] = "SRCARCH value" - os.environ["srctree"] = "srctree value" - c = kconfiglib.Config("Kconfiglib/tests/Kmisc", print_warnings = False) - c.load_config("Kconfiglib/tests/empty") - - arch = c.get_arch() - srcarch = c.get_srcarch() - srctree = c.get_srctree() - config_filename = c.get_config_filename() - kconfig_filename = c.get_kconfig_filename() - - print("Testing get_arch()...") - verify(arch == "ARCH value", - "Wrong arch value - got '{}'".format(arch)) - print("Testing get_srcarch()...") - verify(srcarch == "SRCARCH value", - "Wrong srcarch value - got '{}'".format(srcarch)) - print("Testing get_srctree()...") - verify(srctree == "srctree value", - "Wrong srctree value - got '{}'".format(srctree)) - print("Testing get_config_filename()...") - verify(config_filename == "Kconfiglib/tests/empty", - "Wrong config filename - got '{}'".format(config_filename)) - print("Testing get_kconfig_filename()...") - verify(kconfig_filename == "Kconfiglib/tests/Kmisc", - "Wrong Kconfig filename - got '{}'".format(kconfig_filename)) + verify((c1_undef is not c2_undef) and (c1_bool is not c2_bool) and + (c1_choice is not c2_choice) and (c1_menu is not c2_menu) and + (c1_comment is not c2_comment) and + (c1_undef.config is c1) and (c2_undef.config is c2) and + (c1_bool.config is c1) and (c2_bool.config is c2) and + (c1_choice.config is c1) and (c2_choice.config is c2) and + (c1_menu.config is c1) and (c2_menu.config is c2) and + (c1_comment.config is c1) and (c2_comment.config is c2), + "Config instance state separation or .config is broken") # # Imply semantics @@ -1887,7 +1474,7 @@ def run_selftests(): assign_and_verify("IMPLIED_TRISTATE", "n") assign_and_verify("IMPLIED_TRISTATE", "m") assign_and_verify("IMPLIED_TRISTATE", "y") - c["IMPLIED_TRISTATE"].unset_user_value() + c.syms["IMPLIED_TRISTATE"].unset_value() verify_value("IMPLIED_TRISTATE", "n") # Same as above for "m". Anything still goes, but "m" by default now. @@ -1896,7 +1483,7 @@ def run_selftests(): assign_and_verify("IMPLIED_TRISTATE", "n") assign_and_verify("IMPLIED_TRISTATE", "m") assign_and_verify("IMPLIED_TRISTATE", "y") - c["IMPLIED_TRISTATE"].unset_user_value() + c.syms["IMPLIED_TRISTATE"].unset_value() verify_value("IMPLIED_TRISTATE", "m") # Same as above for "y". Only "n" and "y" should be accepted. "m" gets @@ -1904,14 +1491,14 @@ def run_selftests(): assign_and_verify("IMPLY", "y") assign_and_verify("IMPLIED_TRISTATE", "n") - assign_and_verify_new_value("IMPLIED_TRISTATE", "m", "y") + assign_and_verify_value("IMPLIED_TRISTATE", "m", "y") assign_and_verify("IMPLIED_TRISTATE", "y") - c["IMPLIED_TRISTATE"].unset_user_value() + c.syms["IMPLIED_TRISTATE"].unset_value() verify_value("IMPLIED_TRISTATE", "y") # Being implied to either "m" or "y" should give a bool the value "y" - c["IMPLY"].unset_user_value() + c.syms["IMPLY"].unset_value() verify_value("IMPLIED_BOOL", "n") assign_and_verify("IMPLY", "n") verify_value("IMPLIED_BOOL", "n") @@ -1922,11 +1509,11 @@ def run_selftests(): # A bool implied to "m" or "y" can take the values "n" and "y" - c["IMPLY"].set_user_value("m") + c.syms["IMPLY"].set_value("m") assign_and_verify("IMPLIED_BOOL", "n") assign_and_verify("IMPLIED_BOOL", "y") - c["IMPLY"].set_user_value("y") + c.syms["IMPLY"].set_value("y") assign_and_verify("IMPLIED_BOOL", "n") assign_and_verify("IMPLIED_BOOL", "y") @@ -1942,90 +1529,82 @@ def run_selftests(): choice_bool_m, choice_tristate_m, choice_defaults, \ choice_defaults_not_visible, choice_no_type_bool, \ choice_no_type_tristate, choice_missing_member_type_1, \ - choice_missing_member_type_2, choice_weird_syms = c.get_choices() + choice_missing_member_type_2, choice_weird_syms = get_choices(c) for choice in (choice_bool, choice_bool_opt, choice_bool_m, choice_defaults): - verify(choice.get_type() == kconfiglib.BOOL, - "choice {} should have type bool".format(choice.get_name())) + verify(choice.type == kconfiglib.BOOL, + "choice {} should have type bool".format(choice.name)) - for choice in (choice_tristate, choice_tristate_opt, choice_tristate_m): - verify(choice.get_type() == kconfiglib.TRISTATE, - "choice {} should have type tristate" - .format(choice.get_name())) + # TODO: fix this laters. type automatically changed. + #for choice in (choice_tristate, choice_tristate_opt, choice_tristate_m): + # verify(choice.type == kconfiglib.TRISTATE, + # "choice {} should have type tristate" + # .format(choice.name)) def select_and_verify(sym): - choice = sym.get_parent() - sym.set_user_value("y") - verify(choice.get_mode() == "y", + choice = get_parent(sym) + sym.set_value("y") + verify(choice.value == "y", 'The mode of the choice should be "y" after selecting a ' "symbol") - verify(sym.is_choice_selection(), - "is_choice_selection() should be true for {}" - .format(sym.get_name())) - verify(choice.get_selection() is sym, - "{} should be the selected symbol".format(sym.get_name())) - verify(choice.get_user_selection() is sym, + verify(sym.choice.selection is sym, + "{} should be the selected choice symbol" + .format(sym.name)) + verify(choice.selection is sym, + "{} should be the selected symbol".format(sym.name)) + verify(choice.user_selection is sym, "{} should be the user selection of the choice" - .format(sym.get_name())) + .format(sym.name)) def select_and_verify_all(choice): - choice_syms = choice.get_symbols() # Select in forward order - for sym in choice_syms: + for sym in choice.syms: select_and_verify(sym) # Select in reverse order - for i in range(len(choice_syms) - 1, 0, -1): - select_and_verify(choice_syms[i]) + for i in range(len(choice.syms) - 1, 0, -1): + select_and_verify(choice.syms[i]) def verify_mode(choice, no_modules_mode, modules_mode): - c["MODULES"].set_user_value("n") - choice_mode = choice.get_mode() + c.syms["MODULES"].set_value("n") + choice_mode = choice.value verify(choice_mode == no_modules_mode, 'Wrong mode for choice {} with no modules. Expected "{}", ' - 'got "{}".'.format(choice.get_name(), no_modules_mode, - choice_mode)) + 'got "{}".'.format(choice.name, no_modules_mode, choice_mode)) - c["MODULES"].set_user_value("y") - choice_mode = choice.get_mode() + c.syms["MODULES"].set_value("y") + choice_mode = choice.value verify(choice_mode == modules_mode, 'Wrong mode for choice {} with modules. Expected "{}", ' - 'got "{}".'.format(choice.get_name(), modules_mode, + 'got "{}".'.format(choice.name, modules_mode, choice_mode)) verify_mode(choice_bool, "y", "y") verify_mode(choice_bool_opt, "n", "n") verify_mode(choice_tristate, "y", "m") verify_mode(choice_tristate_opt, "n", "n") - verify_mode(choice_bool_m, "n", "y") # Promoted - verify_mode(choice_tristate_m, "n", "m") + verify_mode(choice_bool_m, "y", "y") + verify_mode(choice_tristate_m, "y", "m") # Test defaults - c["TRISTATE_SYM"].set_user_value("n") - verify(choice_defaults.get_selection_from_defaults() is c["OPT_4"] and - choice_defaults.get_selection() is c["OPT_4"], + c.syms["TRISTATE_SYM"].set_value("n") + verify(choice_defaults.selection is c.syms["OPT_4"], "Wrong choice default with TRISTATE_SYM = n") - c["TRISTATE_SYM"].set_user_value("y") - verify(choice_defaults.get_selection_from_defaults() is c["OPT_2"] and - choice_defaults.get_selection() is c["OPT_2"], + c.syms["TRISTATE_SYM"].set_value("y") + verify(choice_defaults.selection is c.syms["OPT_2"], "Wrong choice default with TRISTATE_SYM = y") - c["OPT_1"].set_user_value("y") - verify(choice_defaults.get_selection_from_defaults() is c["OPT_2"], - "User selection changed default selection - shouldn't have") - verify(choice_defaults.get_selection() is c["OPT_1"], + c.syms["OPT_1"].set_value("y") + verify(choice_defaults.selection is c.syms["OPT_1"], "User selection should override defaults") - verify(choice_defaults_not_visible.get_selection_from_defaults() - is c["OPT_8"] and - choice_defaults_not_visible.get_selection() - is c["OPT_8"], + verify(choice_defaults_not_visible.selection is c.syms["OPT_8"], "Non-visible choice symbols should cause the next default to be " "considered") # Test "y" mode selection - c["MODULES"].set_user_value("y") + c.syms["MODULES"].set_value("y") select_and_verify_all(choice_bool) select_and_verify_all(choice_bool_opt) @@ -2039,70 +1618,76 @@ def run_selftests(): # ...for a choice that can also be in "y" mode for sym_name in ("T_1", "T_2"): - assign_and_verify_new_value(sym_name, "m", "m") - verify(choice_tristate.get_mode() == "m", + assign_and_verify_value(sym_name, "m", "m") + verify(choice_tristate.value == "m", 'Selecting {} to "m" should have changed the mode of the ' 'choice to "m"'.format(sym_name)) - assign_and_verify_new_value(sym_name, "y", "y") - verify(choice_tristate.get_mode() == "y" and - choice_tristate.get_selection() is c[sym_name], + assign_and_verify_value(sym_name, "y", "y") + verify(choice_tristate.value == "y" and + choice_tristate.selection is c.syms[sym_name], 'Selecting {} to "y" should have changed the mode of the ' 'choice to "y" and made it the selection'.format(sym_name)) # ...for a choice that can only be in "m" mode for sym_name in ("TM_1", "TM_2"): - assign_and_verify_new_value(sym_name, "m", "m") - assign_and_verify_new_value(sym_name, "n", "n") + assign_and_verify_value(sym_name, "m", "m") + assign_and_verify_value(sym_name, "n", "n") # "y" should be truncated - assign_and_verify_new_value(sym_name, "y", "m") - verify(choice_tristate_m.get_mode() == "m", + assign_and_verify_value(sym_name, "y", "m") + verify(choice_tristate_m.value == "m", 'A choice that can only be in "m" mode was not') # Verify that choices with no explicitly specified type get the type of the # first contained symbol with a type - verify(choice_no_type_bool.get_type() == kconfiglib.BOOL, + verify(choice_no_type_bool.type == kconfiglib.BOOL, "Expected first choice without explicit type to have type bool") - verify(choice_no_type_tristate.get_type() == kconfiglib.TRISTATE, + verify(choice_no_type_tristate.type == kconfiglib.TRISTATE, "Expected second choice without explicit type to have type " "tristate") # Verify that symbols without a type in the choice get the type of the # choice - verify((c["MMT_1"].get_type(), c["MMT_2"].get_type(), - c["MMT_3"].get_type()) == + verify((c.syms["MMT_1"]._type, c.syms["MMT_2"]._type, + c.syms["MMT_3"]._type) == (kconfiglib.BOOL, kconfiglib.BOOL, kconfiglib.TRISTATE), "Wrong types for first choice with missing member types") - verify((c["MMT_4"].get_type(), c["MMT_5"].get_type()) == + verify((c.syms["MMT_4"]._type, c.syms["MMT_5"]._type) == (kconfiglib.BOOL, kconfiglib.BOOL), "Wrong types for second choice with missing member types") # Verify that symbols in choices that depend on the preceding symbol aren't # considered choice symbols - def verify_is_normal_choice_symbol(sym): - verify(sym.is_choice_symbol() and - sym in choice_weird_syms.get_symbols() and - sym.get_parent() is choice_weird_syms, - "{} should be a normal choice symbol".format(sym.get_name())) - - def verify_is_weird_choice_symbol(sym): - verify(not sym.is_choice_symbol() and - sym not in choice_weird_syms.get_symbols() and - sym in choice_weird_syms.get_items() and - sym.get_parent() is choice_weird_syms, - "{} should be a weird (non-)choice symbol") - - verify_is_normal_choice_symbol(c["WS1"]) - verify_is_weird_choice_symbol(c["WS2"]) - verify_is_weird_choice_symbol(c["WS3"]) - verify_is_weird_choice_symbol(c["WS4"]) - verify_is_normal_choice_symbol(c["WS5"]) - verify_is_weird_choice_symbol(c["WS6"]) + def verify_is_normal_choice_symbol(name): + sym = c.syms[name] + verify(sym.choice is not None and + sym in choice_weird_syms.syms and + get_parent(sym) is choice_weird_syms, + "{} should be a normal choice symbol".format(sym.name)) + + # TODO: parent stuff + + def verify_is_weird_choice_symbol(name): + sym = c.syms[name] + verify(sym.choice is None and + sym not in choice_weird_syms.syms, + "{} should be a weird (non-)choice symbol" + .format(sym.name)) + + verify_is_normal_choice_symbol("WS1") + verify_is_weird_choice_symbol("WS2") + verify_is_weird_choice_symbol("WS3") + verify_is_weird_choice_symbol("WS4") + verify_is_weird_choice_symbol("WS5") + verify_is_normal_choice_symbol("WS6") + verify_is_weird_choice_symbol("WS7") + verify_is_weird_choice_symbol("WS8") + verify_is_normal_choice_symbol("WS9") # # Object dependencies @@ -2115,27 +1700,29 @@ def run_selftests(): c = kconfiglib.Config("Kconfiglib/tests/Kdep") def verify_dependent(sym_name, deps_names): - sym = c[sym_name] - deps = [c[name] for name in deps_names] + sym = c.syms[sym_name] + deps = [c.syms[name] for name in deps_names] sym_deps = sym._get_dependent() - verify(len(sym_deps) == len(deps), - "Wrong number of dependent symbols for {}".format(sym_name)) verify(len(sym_deps) == len(set(sym_deps)), "{}'s dependencies contains duplicates".format(sym_name)) + sym_deps = [item for item in sym_deps + if not isinstance(item, kconfiglib.Choice)] + verify(len(sym_deps) == len(deps), + "Wrong number of dependent symbols for {}".format(sym_name)) for dep in deps: verify(dep in sym_deps, "{} should depend on {}". - format(dep.get_name(), sym_name)) + format(dep.name, sym_name)) # Test twice to cover dependency caching for i in range(0, 2): n_deps = 39 # Verify that D1, D2, .., D<n_deps> are dependent on D - verify_dependent("D", ["D{}".format(i) for i in range(1, n_deps + 1)]) + verify_dependent("D", ("D{}".format(i) for i in range(1, n_deps + 1))) # Choices - verify_dependent("A", ["B", "C"]) - verify_dependent("B", ["A", "C"]) - verify_dependent("C", ["A", "B"]) - verify_dependent("S", ["A", "B", "C"]) + verify_dependent("A", ("B", "C")) + verify_dependent("B", ("A", "C")) + verify_dependent("C", ("A", "B")) + verify_dependent("S", ("A", "B", "C")) # Verify that the last symbol depends on the first in a long chain of # dependencies. Test twice to cover dependency caching. @@ -2143,21 +1730,28 @@ def run_selftests(): c = kconfiglib.Config("Kconfiglib/tests/Kchain") for i in range(0, 2): - verify(c["CHAIN_26"] in c["CHAIN_1"]._get_dependent(), + verify(c.syms["CHAIN_26"] in c.syms["CHAIN_1"]._get_dependent(), "Dependency chain broken") - print("\nAll selftests passed\n" if _all_ok else + print("Testing compatibility with weird selects/implies...") + + # Check that Kconfiglib doesn't crash for stuff like 'select n' (seen in + # U-Boot). These probably originate from misunderstandings of how Kconfig + # works. + kconfiglib.Config("Kconfiglib/tests/Kwtf") + + print("\nAll selftests passed\n" if all_passed else "\nSome selftests failed\n") def run_compatibility_tests(): """Runs tests on configurations from the kernel. Tests compability with the C implementation by comparing outputs.""" - del os.environ["ARCH"] - del os.environ["SRCARCH"] - del os.environ["srctree"] + os.environ.pop("ARCH", None) + os.environ.pop("SRCARCH", None) + os.environ.pop("srctree", None) - if speedy_mode and not os.path.exists("scripts/kconfig/conf"): + if speedy and not os.path.exists("scripts/kconfig/conf"): print("\nscripts/kconfig/conf does not exist -- running " "'make allnoconfig' to build it...") shell("make allnoconfig") @@ -2193,11 +1787,11 @@ def run_compatibility_tests(): # Previously we used to load all the arches once and keep them # around for the tests. That now uses a huge amount of memory (pypy # helps a bit), so reload them for each test instead. - test_fn(kconfiglib.Config(base_dir=".")) + test_fn(kconfiglib.Config(), arch) # Let kbuild infer SRCARCH from ARCH if we aren't in speedy mode. # This could detect issues with the test suite. - if not speedy_mode: + if not speedy: del os.environ["SRCARCH"] if compare_configs: @@ -2207,7 +1801,7 @@ def run_compatibility_tests(): print(" {:14}FAIL".format(arch)) fail() - if all_ok(): + if all_passed: print("All selftests and compatibility tests passed") print(nconfigs, "arch/defconfig pairs tested") else: @@ -2240,13 +1834,13 @@ def get_arch_srcarch_list(): return res -def test_load(conf): +def test_load(conf, arch): """Load all arch Kconfigs to make sure we don't throw any errors""" - print(" {:14}OK".format(conf.get_arch())) + print(" {:14}OK".format(arch)) # The weird docstring formatting is to get the format right when we print the # docstring ourselves -def test_all_no(conf): +def test_all_no(conf, arch): """ Verify that our examples/allnoconfig.py script generates the same .config as 'make allnoconfig', for each architecture. Runs the script via @@ -2256,12 +1850,12 @@ def test_all_no(conf): shell("make scriptconfig SCRIPT=Kconfiglib/examples/allnoconfig.py " "PYTHONCMD='{}'".format(sys.executable)) shell("mv .config ._config") - if speedy_mode: + if speedy: shell("scripts/kconfig/conf --allnoconfig Kconfig") else: shell("make allnoconfig") -def test_all_no_simpler(conf): +def test_all_no_simpler(conf, arch): """ Verify that our examples/allnoconfig_simpler.py script generates the same .config as 'make allnoconfig', for each architecture. Runs the script via @@ -2271,12 +1865,12 @@ def test_all_no_simpler(conf): shell("make scriptconfig SCRIPT=Kconfiglib/examples/allnoconfig_simpler.py " "PYTHONCMD='{}'".format(sys.executable)) shell("mv .config ._config") - if speedy_mode: + if speedy: shell("scripts/kconfig/conf --allnoconfig Kconfig") else: shell("make allnoconfig") -def test_all_yes(conf): +def test_all_yes(conf, arch): """ Verify that our examples/allyesconfig.py script generates the same .config as 'make allyesconfig', for each architecture. Runs the script via @@ -2286,157 +1880,59 @@ def test_all_yes(conf): shell("make scriptconfig SCRIPT=Kconfiglib/examples/allyesconfig.py " "PYTHONCMD='{}'".format(sys.executable)) shell("mv .config ._config") - if speedy_mode: + if speedy: shell("scripts/kconfig/conf --allyesconfig Kconfig") else: shell("make allyesconfig") -def test_call_all(conf): +def test_call_all(conf, arch): """ Call all public methods on all symbols, menus, choices, and comments for all architectures to make sure we never crash or hang. (Nearly all public methods: some are hard to test like this, but are exercised by other - tests.) Also do misc. sanity checks.""" - print(" For {}...".format(conf.get_arch())) - - conf.__str__() - conf.get_arch() - conf.get_base_dir() - conf.get_config_filename() - conf.get_config_header() - conf.get_defconfig_filename() - conf.get_kconfig_filename() - conf.get_mainmenu_text() - conf.get_srcarch() - conf.get_srctree() - conf.get_symbol("y") - conf.get_symbols(False) - conf.get_top_level_items() - conf.set_print_undef_assign(True) - conf.set_print_undef_assign(False) - conf.set_print_warnings(False) - conf.set_print_warnings(True) - conf.unset_user_values() - - conf.eval("y && ARCH") - - for s in conf.get_symbols(): + tests.)""" + print(" For {}...".format(arch)) + + conf.defconfig_filename + conf.mainmenu_text + conf.enable_undef_warnings() + conf.disable_undef_warnings() + conf.disable_warnings() + conf.enable_warnings() + conf.unset_values() + + # Python 2/3 compatible + for _, s in conf.syms.items(): s.__str__() - s.get_assignable_values() - s.get_config() - s.get_help() - s.get_implied_symbols() - s.get_lower_bound() - s.get_name() - s.get_parent() - s.get_prompts() - s.get_ref_locations() - s.get_referenced_symbols() - s.get_referenced_symbols(True) - s.get_selected_symbols() - s.get_type() - s.get_upper_bound() - s.get_user_value() - s.get_value() - s.get_visibility() - s.has_ranges() - s.is_choice_selection() - s.is_choice_symbol() - s.is_defined() - s.is_from_environment() - s.is_modifiable() - s.is_allnoconfig_y() - s.unset_user_value() - - # Check get_ref/def_location() sanity - - if s.is_special(): - if s.is_from_environment(): - # Special symbols from the environment should have define - # locations - verify(s.get_def_locations() != [], - "The symbol '{}' is from the environment but lacks " - "define locations".format(s.get_name())) - else: - # Special symbols that are not from the environment should be - # defined and have no define locations - verify(s.is_defined(), - "The special symbol '{}' is not defined". - format(s.get_name())) - verify(s.get_def_locations() == [], - "The special symbol '{}' has recorded def. locations". - format(s.get_name())) - else: - # Non-special symbols should have define locations iff they are - # defined - if s.is_defined(): - verify(s.get_def_locations() != [], - "'{}' defined but lacks recorded locations". - format(s.get_name())) - else: - verify(s.get_def_locations() == [], - "'{}' undefined but has recorded locations". - format(s.get_name())) - verify(s.get_ref_locations() != [], - "'{}' both undefined and unreferenced". - format(s.get_name())) - - for c in conf.get_choices(): + s.__repr__() + s.assignable + s.type + s.value + s.visibility + s.unset_value() + + # Cheat with internals + for c in conf._choices: c.__str__() - c.get_config() - c.get_def_locations() - c.get_help() - c.get_items() - c.get_mode() - c.get_name() - c.get_parent() - c.get_prompts() - c.get_referenced_symbols() - c.get_referenced_symbols(True) - c.get_selection() - c.get_selection_from_defaults() - c.get_symbols() - c.get_type() - c.get_user_selection() - c.get_visibility() - c.is_optional() - - for m in conf.get_menus(): - m.__str__() - m.get_config() - m.get_items() - m.get_items(True) - m.get_location() - m.get_parent() - m.get_referenced_symbols() - m.get_referenced_symbols(True) - m.get_symbols() - m.get_symbols(True) - m.get_title() - m.get_visibility() - m.get_visible_if_visibility() - - for c in conf.get_comments(): - c.__str__() - c.get_config() - c.get_location() - c.get_parent() - c.get_referenced_symbols() - c.get_referenced_symbols(True) - c.get_text() - c.get_visibility() - -def test_config_absent(conf): + c.__repr__() + c.value + c.assignable + c.selection + c.default_selection + c.type + c.visibility + +def test_config_absent(conf, arch): """ Verify that Kconfiglib generates the same .config as 'make alldefconfig', for each architecture""" conf.write_config("._config") - if speedy_mode: + if speedy: shell("scripts/kconfig/conf --alldefconfig Kconfig") else: shell("make alldefconfig") -def test_defconfig(conf): +def test_defconfig(conf, arch): """ Verify that Kconfiglib generates the same .config as scripts/kconfig/conf, for each architecture/defconfig pair. In obsessive mode, this test includes @@ -2450,8 +1946,8 @@ def test_defconfig(conf): global nconfigs defconfigs = [] - def add_configs_for_arch(arch): - arch_dir = os.path.join("arch", arch) + def add_configs_for_arch(arch_): + arch_dir = os.path.join("arch", arch_) # Some arches have a "defconfig" in the root of their arch/<arch>/ # directory root_defconfig = os.path.join(arch_dir, "defconfig") @@ -2470,13 +1966,13 @@ def test_defconfig(conf): for filename in filenames: defconfigs.append(os.path.join(dirpath, filename)) - if obsessive_mode: + if obsessive: # Collect all defconfigs. This could be done once instead, but it's # a speedy operation comparatively. - for arch in os.listdir("arch"): - add_configs_for_arch(arch) + for arch_ in os.listdir("arch"): + add_configs_for_arch(arch_) else: - add_configs_for_arch(conf.get_arch()) + add_configs_for_arch(arch) # Test architecture for each defconfig @@ -2487,7 +1983,7 @@ def test_defconfig(conf): conf.load_config(defconfig) conf.write_config("._config") - if speedy_mode: + if speedy: shell("scripts/kconfig/conf --defconfig='{}' Kconfig". format(defconfig)) else: @@ -2500,31 +1996,24 @@ def test_defconfig(conf): # bugs. shell("make kconfiglibtestconfig") - arch_defconfig_str = " {:14}with {:60} " \ - .format(conf.get_arch(), defconfig) + arch_defconfig_str = " {:14}with {:60} ".format(arch, defconfig) if equal_confs(): print(arch_defconfig_str + "OK") else: print(arch_defconfig_str + "FAIL") fail() - if log_mode: + if log: with open("test_defconfig_fails", "a") as fail_log: fail_log.write("{} {} with {} did not match\n" .format(time.strftime("%d %b %Y %H:%M:%S", time.localtime()), - conf.get_arch(), - defconfig)) + arch, defconfig)) # # Helper functions # -devnull = open(os.devnull, "w") - -def shell(cmd): - subprocess.call(cmd, shell = True, stdout = devnull, stderr = devnull) - def rm_configs(): """Delete any old ".config" (generated by the C implementation) and "._config" (generated by us), if present.""" @@ -2557,7 +2046,8 @@ def equal_confs(): return False else: with f: - our = f.readlines() + # [1:] strips the default header + our = f.readlines()[1:] if their == our: return True @@ -2569,26 +2059,5 @@ def equal_confs(): return False -_all_ok = True - -def verify(cond, msg): - """Fails and prints 'msg' if 'cond' is False.""" - if not cond: - fail(msg) - -def verify_equals(x, y): - """Fails if 'x' does not equal 'y'.""" - if x != y: - fail("'{}' does not equal '{}'".format(x, y)) - -def fail(msg = None): - global _all_ok - if msg is not None: - print("Fail: " + msg) - _all_ok = False - -def all_ok(): - return _all_ok - if __name__ == "__main__": run_tests() |