lkml.org 
[lkml]   [2011]   [Feb]   [1]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[PATCH] [ANNOUNCE] kconfig: Kconfiglib: a flexible Python Kconfig parser
    Hi,

    This is the initial release of Kconfiglib: a Python library for
    scripting, debugging, and extracting information from Kconfig-based
    configuration systems. It can be used to programmatically generate a
    .config when the '*conf' tools are too inflexible, to quickly find out
    interesting information about a Kconfig configuration such as dependency
    relations between symbols and where undefined symbols are referenced,
    and in applications that need to parse and extract information from
    Kconfig files.

    For a much longer introduction including multiple examples, see
    arch/kconfig/kconfiglib.py.

    Have fun!

    Signed-off-by: Ulf Magnusson <ulfalizer.lkml@gmail.com>
    ---
    Convenience links:

    Documentation, generated from kconfiglib.py with pydoc -w:
    http://dl.dropbox.com/u/10406197/kconfiglib.html

    Examples as separate files:
    http://dl.dropbox.com/u/10406197/kconfiglib-examples.tar.gz


    The patch should be preferably be applied to a recent kernel, i.e. Linus's
    (2.6.38-rc3 at the time of writing). Due to recent Kconfig changes, the
    kconfigtest.py test suite - which compares output character-for-character -
    will indicate failure on older (a few months old) kernels versions even though
    the outputs are functionally equivalent.

    Documentation/kbuild/kconfig-language.txt | 5 +
    Documentation/kbuild/kconfig.txt | 8 +
    README | 13 +
    scripts/kconfig/Makefile | 26 +-
    scripts/kconfig/kconfiglib.py | 3918 +++++++++++++++++++++++++++++
    scripts/kconfig/kconfigtest.py | 396 +++
    6 files changed, 4365 insertions(+), 1 deletions(-)
    create mode 100644 scripts/kconfig/kconfiglib.py
    create mode 100644 scripts/kconfig/kconfigtest.py

    diff --git a/Documentation/kbuild/kconfig-language.txt b/Documentation/kbuild/kconfig-language.txt
    index b507d61..63d63ba 100644
    --- a/Documentation/kbuild/kconfig-language.txt
    +++ b/Documentation/kbuild/kconfig-language.txt
    @@ -381,3 +381,8 @@ config FOO

    limits FOO to module (=m) or disabled (=n).

    +Kconfiglib
    +~~~~~~~~~~
    +If you need to programmatically generate a .config or parse Kconfig files,
    +Kconfiglib might come handy. See 'scriptconfig' and 'iscriptconfig' in
    +'make help' and scripts/kconfig/kconfiglib.py.
    diff --git a/Documentation/kbuild/kconfig.txt b/Documentation/kbuild/kconfig.txt
    index cca46b1..73cf58f 100644
    --- a/Documentation/kbuild/kconfig.txt
    +++ b/Documentation/kbuild/kconfig.txt
    @@ -195,4 +195,12 @@ Searching in gconfig:
    however, gconfig does have a few more viewing choices than
    xconfig does.

    +======================================================================
    +scriptconfig
    +--------------------------------------------------
    +
    +If you need to programmatically generate a .config or parse Kconfig files,
    +Kconfiglib might come handy. See 'scriptconfig' and 'iscriptconfig' in
    +'make help' and scripts/kconfig/kconfiglib.py.
    +
    ###
    diff --git a/README b/README
    index 1b81d28..bb5e68f 100644
    --- a/README
    +++ b/README
    @@ -196,6 +196,19 @@ CONFIGURING the kernel:
    values to 'n' as much as possible.
    "make randconfig" Create a ./.config file by setting symbol
    values to random values.
    + "make scriptconfig SCRIPT=<path to script>" Run a Kconfiglib
    + script (see scripts/kconfig/kconfiglib.py). This
    + can be used to programatically generate a
    + ./.config, and for applications that need to
    + extract information from Kconfig files.
    + "make iscriptconfig" Launch an interactive Python shell
    + for running Kconfiglib on the architecture's
    + Kconfig configuration. The kconfiglib and sys
    + (for sys.argv[1] - the base Kconfig file) modules
    + will be imported automatically, and a Config
    + instance 'c' will be created for the architecture
    + (using c = kconfiglib.Config(sys.argv[1])).
    +

    You can find more information on using the Linux kernel config tools
    in Documentation/kbuild/kconfig.txt.
    diff --git a/scripts/kconfig/Makefile b/scripts/kconfig/Makefile
    index 368ae30..cfffe87 100644
    --- a/scripts/kconfig/Makefile
    +++ b/scripts/kconfig/Makefile
    @@ -3,7 +3,7 @@
    # These targets are used from top-level makefile

    PHONY += oldconfig xconfig gconfig menuconfig config silentoldconfig update-po-config \
    - localmodconfig localyesconfig
    + localmodconfig localyesconfig scriptconfig iscriptconfig kconfiglibtestconfig

    ifdef KBUILD_KCONFIG
    Kconfig := $(KBUILD_KCONFIG)
    @@ -33,6 +33,28 @@ silentoldconfig: $(obj)/conf
    $(Q)mkdir -p include/generated
    $< --$@ $(Kconfig)

    +ifneq ($(filter scriptconfig iscriptconfig,$(MAKECMDGOALS)),)
    +PYTHONCMD ?= python
    +endif
    +
    +scriptconfig:
    + $(Q)if [ ! -n "$(SCRIPT)" ]; then \
    + echo 'No script argument provided; use "make scriptconfig SCRIPT=<path to script>".'; \
    + else \
    + PYTHONPATH="$(obj):$$PYTHONPATH" "$(PYTHONCMD)" "$(SCRIPT)" "$(Kconfig)"; \
    + fi
    +
    +iscriptconfig:
    + $(Q)PYTHONPATH="$(obj):$$PYTHONPATH" "$(PYTHONCMD)" -i -c \
    + "import kconfiglib; \
    + import sys; \
    + c = kconfiglib.Config(sys.argv[1]); \
    + print \"A Config instance 'c' for the architecture ({0}) has been created.\".format(c.get_arch())" "$(Kconfig)"
    +
    +# Used by kconfigtest.py to prevent an 'option defconfig' .config from being loaded
    +kconfiglibtestconfig: $(obj)/conf
    + $(Q)$< --defconfig=.config $(Kconfig)
    +
    # if no path is given, then use src directory to find file
    ifdef LSMOD
    LSMOD_F := $(LSMOD)
    @@ -139,6 +161,8 @@ help:
    @echo ' randconfig - New config with random answer to all options'
    @echo ' listnewconfig - List new options'
    @echo ' oldnoconfig - Same as silentoldconfig but set new symbols to n (unset)'
    + @echo ' scriptconfig - Run a kconfiglib script (see scripts/kconfig/kconfiglib.py)'
    + @echo ' iscriptconfig - Launch interactive Python shell for using kconfiglib'

    # lxdialog stuff
    check-lxdialog := $(srctree)/$(src)/lxdialog/check-lxdialog.sh
    diff --git a/scripts/kconfig/kconfiglib.py b/scripts/kconfig/kconfiglib.py
    new file mode 100644
    index 0000000..84e70c3
    --- /dev/null
    +++ b/scripts/kconfig/kconfiglib.py
    @@ -0,0 +1,3918 @@
    +# This is Kconfiglib, a Python library for scripting, debugging, and extracing
    +# information from Kconfig-based configuration systems. To view the
    +# documentation, run
    +#
    +# $ pydoc kconfiglib
    +#
    +# or, if you prefer HTML,
    +#
    +# $ pydoc -w kconfiglib
    +#
    +# By Ulf "Ulfalizer" Magnusson.
    +
    +"""
    +Kconfiglib is a Python library for scripting, debugging, and extracting
    +information from Kconfig-based configuration systems. Features include the
    +following:
    +
    + - 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.
    + - Symbol values are automatically cached and reevaluated only when needed.
    + - Highly compatible with the C Kconfig implementation:
    + * Generates a .config file that is character-for-character identical (modulo
    + header) to the one generated by the C implementation (mconf) when fed each
    + architecture/defconfig pair in the kernel and asked to generate a
    + configuration. This includes nonsensical pairings such as powerpc with
    + arch/x86/configs/x86_64_defconfig, for a total of 9096 combinations as of
    + Linux 2.6.38-rc3.
    + * Also generates a .config that is character-for-character identical to the
    + one generated by mconf for all architectures when no .config is supplied.
    + * The 'make allyesconfig' and 'make allnoconfig' implementations below
    + generate output character-for-character identical to the C implementation
    + for all architectures.
    +
    + See scripts/kconfig/kconfigtest.py for the Kconfiglib test suite.
    +
    +For the Linux kernel, scripts should be run with
    +
    +$ make scriptconfig SCRIPT=<path to script>
    +
    +to ensure that the environment (SRCARCH, ARCH, and KERNELVERSION) is set up
    +correctly. Alternative architectures can be specified like for other 'make
    +*config' targets:
    +
    +$ make scriptconfig ARCH=mips SCRIPT=<path to script>
    +
    +The script will receive the name of the Kconfig file to load in sys.argv[1] (as
    +of Linux 2.6.38-rc3 this is always "Kconfig" from the kernel top-level
    +directory).
    +
    +To get an interactive Python prompt with Kconfiglib preloaded, use
    +
    +$ make iscriptconfig ARCH=<architecture>
    +
    +Kconfiglib requires Python 2. For (i)scriptconfig the command to run the Python
    +interpreter can be passed in the environment variable PYTHONCMD (defaults to
    +'python').
    +
    +Learning to use the library is probably easiest by looking at a few examples,
    +reading the documentation, and experimenting. The API is designed to be
    +intuitive and easy to use.
    +
    +===============================================================================
    +Example 1: loading a configuration and a .config and printing information about
    +a symbol.
    +
    +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).
    +conf = kconfiglib.Config(sys.argv[1])
    +
    +# Load values from a .config file.
    +conf.load_config("arch/x86/configs/i386_defconfig")
    +
    +# Print some information about a symbol (the Config class implements
    +# __getitem__() to provide a handy syntax for getting symbols).
    +print conf["SERIAL_UARTLITE_CONSOLE"]
    +
    +Output for ARCH=i386:
    +Symbol SERIAL_UARTLITE_CONSOLE
    +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:
    + "Support for console on Xilinx uartlite serial port" if SERIAL_UARTLITE = y (value: "n")
    +Default values:
    + (no default values)
    +Selects:
    + SERIAL_CORE_CONSOLE if SERIAL_UARTLITE = y (value: "n")
    +Reverse dependencies:
    + (no reverse dependencies)
    +Additional dependencies from enclosing menus and if's:
    + HAS_IOMEM (value: "y")
    +Locations: drivers/serial/Kconfig:913
    +
    +===============================================================================
    +Example 2: evaluate an expression in the context of a configuration (here we
    + could load a .config as well).
    +
    +import kconfiglib
    +import sys
    +
    +conf = kconfiglib.Config(sys.argv[1])
    +print conf.eval("(TRACE_IRQFLAGS_SUPPORT || PPC32) && STACKTRACE_SUPPORT")
    +
    +Output for ARCH=mips:
    +y
    +
    +===============================================================================
    +Example 3: print 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)
    +
    +Output for ARCH=i386:
    +MACH_NET2BIG_V2
    + drivers/leds/Kconfig:365
    +MACH_OMAP3517EVM
    + sound/soc/omap/Kconfig:84
    +ARCH_OMAP16XX
    + drivers/pcmcia/Kconfig:271
    + drivers/char/hw_random/Kconfig:117
    + drivers/watchdog/Kconfig:210
    + drivers/rtc/Kconfig:694
    +SOC_JZ4740
    + sound/soc/codecs/Kconfig:30
    +MACH_AT91SAM9261EK
    + drivers/video/Kconfig:1055
    +PPC_83xx
    + drivers/mtd/nand/Kconfig:463
    + drivers/watchdog/Kconfig:951
    + drivers/usb/Kconfig:58
    + drivers/edac/Kconfig:221
    +PPC_PSERIES
    + init/Kconfig:999
    + drivers/pci/hotplug/Kconfig:146
    + drivers/scsi/Kconfig:964
    + drivers/scsi/Kconfig:975
    + drivers/scsi/Kconfig:989
    + drivers/net/Kconfig:1353
    + drivers/serial/Kconfig:1261
    + drivers/char/Kconfig:628
    + drivers/char/Kconfig:712
    + drivers/char/Kconfig:729
    +... (lots more)
    +
    +===============================================================================
    +Example 4: print 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()
    +
    +Output for ARCH=i386:
    +AUDITSYSCALL
    +PCSPKR_PLATFORM
    +OPROFILE_EVENT_MULTIPLEX
    +GCOV_PROFILE_ALL
    +SCHED_OMIT_FRAME_POINTER
    +MEMORY_HOTPLUG
    +PM_TRACE_RTC
    +ACPI
    +ACPI_AC
    +ACPI_BATTERY
    +ACPI_VIDEO
    +ACPI_PROCESSOR_AGGREGATOR
    +ACPI_NUMA
    +X86_PM_TIMER
    +ACPI_SBS
    +ACPI_APEI
    +ACPI_APEI_GHES
    +INTEL_IDLE
    +XEN_PCIDEV_FRONTEND
    +EISA_VLB_PRIMING
    +EISA_VIRTUAL_ROOT
    +HOTPLUG_PCI_COMPAQ
    +HOTPLUG_PCI_IBM
    +HOTPLUG_PCI_CPCI_ZT5550
    +HOTPLUG_PCI_CPCI_GENERIC
    +MTD_SC520CDP
    +... (lots more)
    +
    +===============================================================================
    +Example 5: print a tree of all items in the configuration.
    +
    +import kconfiglib
    +import sys
    +
    +def print_with_indent(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)
    +
    +Output for ARCH=i386:
    +...
    +config ARCH
    +config KERNELVERSION
    +config CONSTRUCTORS
    +config HAVE_IRQ_WORK
    +config IRQ_WORK
    +menu "General setup"
    + config EXPERIMENTAL
    + config BROKEN
    + config BROKEN_ON_SMP
    + config LOCK_KERNEL
    + config INIT_ENV_ARG_LIMIT
    + config CROSS_COMPILE
    + config LOCALVERSION
    + config LOCALVERSION_AUTO
    + config HAVE_KERNEL_GZIP
    + config HAVE_KERNEL_BZIP2
    + config HAVE_KERNEL_LZMA
    + config HAVE_KERNEL_XZ
    + config HAVE_KERNEL_LZO
    + choice
    + config KERNEL_GZIP
    + config KERNEL_BZIP2
    + config KERNEL_LZMA
    + config KERNEL_XZ
    + config KERNEL_LZO
    + config SWAP
    + config SYSVIPC
    + config SYSVIPC_SYSCTL
    + config POSIX_MQUEUE
    + config POSIX_MQUEUE_SYSCTL
    + config BSD_PROCESS_ACCT
    + config BSD_PROCESS_ACCT_V3
    +...
    +
    +===============================================================================
    +Example 6: this does the same thing as entering "make menuconfig" and
    + immediately saving and exiting.
    +
    +import kconfiglib
    +import os
    +import sys
    +
    +conf = kconfiglib.Config(sys.argv[1])
    +
    +if os.path.exists(".config"):
    + conf.load_config(".config")
    +else:
    + defconfig = conf.get_defconfig_filename()
    + if defconfig is not None:
    + print "Using " + defconfig
    + conf.load_config(defconfig)
    +
    +conf.write_config(".config")
    +
    +===============================================================================
    +Example 7: as a more complex example, this is a reimplementation of allnoconfig
    + (verified to produce 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).
    +
    +import kconfiglib
    +import sys
    +
    +conf = kconfiglib.Config(sys.argv[1])
    +
    +while True:
    + 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_item():
    + lower_bound = sym.get_lower_bound()
    +
    + # If we can assign a lower value to the symbol (where "n", "m" and
    + # "y" are ordered from lowest to highest), then do so.
    + # lower_bound() returns None for symbols whose values cannot
    + # (currently) be changed, as well as for non-bool, non-tristate
    + # symbols.
    + if lower_bound is not None and \\
    + kconfiglib.tri_less(lower_bound, sym.calc_value()):
    +
    + sym.set_value(lower_bound)
    +
    + # We just changed the value of some symbol. As this may effect
    + # other symbols, keep going.
    + done = False
    +
    + if done:
    + break
    +
    +conf.write_config(".config")
    +
    +===============================================================================
    +Example 8: here's allyesconfig (also verified), which is a bit more involved
    + as we need to handle choices in two different modes ("y", i.e.
    + one-is-y-rest-is-n, and "m", i.e.
    + any-number-of-symbols-are-m-rest-are-n). The looping is in case
    + setting one symbol to "y" (or "m") allows the value of other symbols
    + to be raised.
    +
    +import kconfiglib
    +import sys
    +
    +conf = kconfiglib.Config(sys.argv[1])
    +
    +# 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_item()]
    +
    +while True:
    + done = 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.calc_value(), upper_bound):
    + sym.set_value(upper_bound)
    + done = False
    +
    + # Handle symbols within choices
    +
    + for choice in conf.get_choices():
    +
    + # Handle choices whose visibility allow them to be in "y" mode
    +
    + if choice.get_visibility() == "y":
    + selection = choice.get_selection_from_defaults()
    + if selection is not None and \\
    + selection is not choice.get_user_selection():
    + selection.set_value("y")
    + done = False
    +
    + # Handle choices whose visibility only allow them to be in "m" mode
    +
    + elif choice.get_visibility() == "m":
    + for sym in choice.get_items():
    + if sym.calc_value() != "m" and \\
    + sym.get_upper_bound() != "n":
    + sym.set_value("m")
    + done = False
    +
    +
    + if done:
    + break
    +
    +conf.write_config(".config")
    +
    +
    +Credits: written by Ulf "Ulfalizer" Magnusson
    +
    +Send bug reports, suggestions (any missing APIs that would make your life
    +easier?) and other feedback to kconfiglib@gmail.com ."""
    +
    +# If you have Psyco installed (32-bit installations, Python <= 2.6 only),
    +# setting this to True (right here, not at runtime) might give a nice speedup
    +# (22% faster for parsing arch/x86/Kconfig and 58% faster for evaluating all
    +# symbols in it without a .config on my Core Duo).
    +use_psyco = False
    +
    +import os
    +import re
    +import string
    +import sys
    +
    +class Config():
    +
    + """Represents a Kconfig configuration."""
    +
    + #
    + # Public interface
    + #
    +
    + def __init__(self,
    + filename = "Kconfig",
    + base_dir = ".",
    + 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, this should usually be be
    + "Kconfig" from the top-level directory, as environment
    + variables will make sure the right Kconfig is included from
    + there (usually arch/<architecture/Kconfig). If you are using
    + kconfiglib via 'make scriptconfig' the filename of the
    + correct Kconfig will be in sys.argv[1].
    +
    + base_dir (default: ".") -- The base directory relative to which
    + 'source' statements within Kconfig files will work. For Linux
    + this should be the top-level directory of the kernel tree.
    +
    + 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.kconfig_syms = []
    +
    + # The set of all named choices (yes, choices can have names), indexed
    + # by name (a string)
    + self.named_choices = {}
    +
    + def register_special_symbol(type, name, value):
    + sym = Symbol()
    + sym.is_special_ = True
    + sym.is_defined_ = True
    + sym.config = self
    + sym.name = name
    + sym.type = type
    + sym.cached_value = value
    + self.syms[name] = sym
    +
    + # The special symbols n, m and y, used as shorthand for "n", "m" and
    + # "y"
    + register_special_symbol(TRISTATE, "n", "n")
    + register_special_symbol(TRISTATE, "m", "m")
    + register_special_symbol(TRISTATE, "y", "y")
    +
    + self.m = self.syms["m"]
    +
    + # Maps a symbol to its directly dependent symbols (any symbol whose
    + # prompt, default value or reverse dependency expressions directly
    + # depend on the symbol)
    + self.dep = {}
    +
    + # The symbol with "option defconfig_list" set, containing a list of
    + # default .config files
    + self.defconfig_sym = None
    +
    + # See Symbol.get_arch()
    + self.arch = os.environ.get("ARCH")
    +
    + self.filename = filename
    + self.base_dir = _strip_trailing_slash(base_dir)
    +
    + # The 'mainmenu' text
    + self.mainmenu_text = None
    +
    + # 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
    +
    + self.print_warnings = print_warnings
    + self.print_undef_assign = print_undef_assign
    +
    + # Lists containing all choices, menus and comments in the configuration
    +
    + self.choices = []
    + self.menus = []
    + self.comments = []
    +
    + # For parsing routines that stop when finding a line belonging to a
    + # different construct, these holds that line and the tokenized version
    + # of that line. The purpose is to avoid having to retokenize the line,
    + # which is inefficient and causes problems when recording references to
    + # symbols.
    + self.end_line = None
    + self.end_line_tokens = None
    +
    + # See the comment in _parse_expr().
    + self.parse_expr_cur_sym_or_choice = None
    + self.parse_expr_line = None
    + self.parse_expr_filename = None
    + self.parse_expr_linenr = None
    + self.parse_expr_transform_m = None
    +
    + # Parse the Kconfig files
    + self.top_block = self._parse_file(filename, None, None, None)
    +
    + # Build self.dep
    + self._build_dep()
    +
    + def load_config(self, filename, reset = True):
    + """Loads symbol values from a file in the familiar .config format.
    +
    + filename -- The .config file to load.
    +
    + reset (default: True) -- True if the configuration should replace
    + the old configuration; False if it should add to it."""
    +
    + def warn_override(filename, linenr, name, old_user_val, new_user_val):
    + self._warn("overriding the value of {0}. "
    + 'Old value: "{1}", new value: "{2}".'
    + .format(name, old_user_val, new_user_val),
    + filename,
    + linenr)
    +
    + # Put this first so that a missing file doesn't screw up our state
    + line_feeder = _FileFeed(_get_lines(filename), filename)
    +
    + self.config_filename = filename
    +
    + if reset:
    + self.reset()
    +
    + # Invalidate everything. This is usually faster than finding the
    + # minimal set of symbols that needs to be invalidated, as nearly all
    + # symbols will tend to be affected anyway.
    + self._invalidate_all()
    +
    + # Read header
    +
    + self.config_header = None
    +
    + def is_header_line(line):
    + return line.startswith("#") and \
    + not re.match(unset_re, line)
    +
    + first_line = line_feeder.get_next()
    +
    + if first_line is None:
    + return
    +
    + if not is_header_line(first_line):
    + line_feeder.go_back()
    + else:
    + self.config_header = first_line[1:]
    +
    + # Read remaining header lines
    + while True:
    + line = line_feeder.get_next()
    +
    + if line is None:
    + break
    +
    + if not is_header_line(line):
    + line_feeder.go_back()
    + break
    +
    + self.config_header += line[1:]
    +
    + # Remove trailing newline
    + if self.config_header.endswith("\n"):
    + self.config_header = self.config_header[:-1]
    +
    + # Read assignments
    +
    + filename = line_feeder.get_filename()
    +
    + while True:
    + line = line_feeder.get_next()
    + if line is None:
    + return
    +
    + linenr = line_feeder.get_linenr()
    +
    + line = line.strip()
    +
    + set_re_match = re.match(set_re, line)
    + if set_re_match:
    + name, val = set_re_match.groups()
    + val = _strip_quotes(val, line, filename, linenr)
    + if name in self.syms:
    + sym = self.syms[name]
    +
    + old_user_val = sym.get_user_value()
    + if old_user_val is not None:
    + warn_override(filename, linenr, name, old_user_val, val)
    +
    + if sym.is_choice_item():
    + user_mode = sym.get_parent()._get_user_mode()
    + if user_mode is not None and user_mode != val:
    + self._warn("assignment to {0} changes mode of containing "
    + 'choice from "{1}" to "{2}".'
    + .format(name, val, user_mode),
    + filename,
    + linenr)
    +
    + sym._set_value_no_invalidate(val, True)
    +
    + else:
    + self._undef_assign('attempt to assign the value "{0}" to the '
    + "undefined symbol {1}."
    + .format(val, name),
    + filename,
    + linenr)
    + continue
    +
    + unset_re_match = re.match(unset_re, line)
    + if unset_re_match:
    + name = unset_re_match.group(1)
    + if name in self.syms:
    + sym = self.syms[name]
    +
    + old_user_val = sym.get_user_value()
    + if old_user_val is not None:
    + warn_override(filename, linenr, name, old_user_val, "n")
    +
    + sym._set_value_no_invalidate("n", True)
    +
    + def write_config(self, filename, header = None):
    + """Writes out symbol values in the familiar .config format.
    +
    + 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. None means no header."""
    +
    + # already_written is set when _make_conf() is called on a symbol, so
    + # that symbols defined in multiple locations only get one entry in the
    + # .config. We need to reset it prior to writing out a new .config.
    + for sym in self.syms.itervalues():
    + sym.already_written = False
    +
    + with open(filename, "w") as f:
    + # Write header
    + if header is not None:
    + f.write(_comment(header))
    + f.write("\n")
    +
    + # Write configuration
    + f.write("\n".join(self.top_block._make_conf()))
    + f.write("\n")
    +
    + def get_kconfig_filename(self):
    + """Returns the name of the (base) kconfig file this configuration was
    + loaded from."""
    + return self.filename
    +
    + def get_arch(self):
    + """Mostly Linux specific. Returns the value the environment variable
    + ARCH had at the time the Config instance was created, or None if ARCH
    + was not defined. This corresponds to the architecture, with values such
    + as "i386" or "mips"."""
    + return self.arch
    +
    + def get_mainmenu_text(self):
    + """Returns the text of the 'mainmenu' statement (with environment
    + variables expanded to the value they had when the Config was created),
    + or None if the configuration has no 'mainmenu' statement."""
    + return 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 environment variables will be
    + expanded. Returns None in case of no defconfig file. Setting 'option
    + defconfig_list' on multiple symbols currently results in undefined
    + behavior."""
    +
    + if self.defconfig_sym is None:
    + return None
    +
    + for (filename, cond_expr) in self.defconfig_sym.def_exprs:
    + cond_val = self._eval_expr(cond_expr)
    + if cond_val == "y":
    + f = os.path.expandvars(filename)
    + if os.path.exists(f):
    + return f
    +
    + 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 get_top_level_items(self):
    + """Returns a list containing the items (symbols, menus, choice
    + statements 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.get_items()
    +
    + 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 self.syms.values() if all_symbols else self.kconfig_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 eval(self, s, transform_m = False):
    + """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'.
    +
    + 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"
    +
    + Note that this functions always yields a tristate value. To get the
    + value of non-bool, non-tristate symbols, use calc_value().
    +
    + transform_m (default: False) --
    + Within conditional expressions (those following e.g. 'if' and
    + 'depends on') "m" is rewritten as "m" && MODULES internally by the C
    + implementation and by kconfiglib, so that MODULES needs to be enabled
    + for the expression to be true. Pass True here if you want that to
    + happen; otherwise, pass False."""
    + return self._eval_expr(self._parse_expr(self._tokenize(s, False),
    + None,
    + s,
    + transform_m = transform_m))
    +
    + 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 comprises all lines up to but not including the first line
    + that either
    +
    + 1. Does not start with "#"
    + 2. Has the form "# CONFIG_FOO is not set."
    + """
    + return self.config_header
    +
    + def get_base_dir(self):
    + """Returns the base directory for 'source' statements, passed as an
    + argument to Config.__init__()."""
    + return self.base_dir
    +
    + def set_print_warnings(self, print_warnings):
    + """Determines whether warnings related to this configuration (for
    + things like attempting to assign illegal values to symbols) should be
    + printed to stderr.
    +
    + print_warnings -- True if warnings should be
    + printed, otherwise False."""
    + self.print_warnings = print_warnings
    +
    + 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.
    +
    + print_undef_assign -- If True, such messages will be printed."""
    + self.print_undef_assign = print_undef_assign
    +
    + def __getitem__(self, key):
    + """Returns the symbol with name 'name'. Raises KeyError if the symbol
    + does not appear in the configuration."""
    + return self.syms[key]
    +
    + 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.kconfig_syms)
    +
    + def reset(self):
    + """Resets the values of all symbols, as if Config.load_config() or
    + Symbol.set_value() had never been called."""
    + for sym in self.syms.itervalues():
    + sym._reset_no_recursive_invalidate()
    +
    + def __str__(self):
    + """Returns a string containing various information about the Config."""
    + return _sep_lines("Configuration",
    + "File : " + self.filename,
    + "Base directory : " + self.base_dir,
    + "Arch (value of ARCH at time of creation) : " + self.arch,
    + "Most recently loaded .config : " +
    + ("(no .config loaded)" if self.config_filename is None else
    + self.config_filename),
    + "Print warnings : " +
    + bool_str[self.print_warnings],
    + "Print assignments to undefined symbols : " +
    + bool_str[self.print_undef_assign])
    +
    +
    + #
    + # Private methods
    + #
    +
    + def _invalidate_all(self):
    + for sym in self.syms.itervalues():
    + sym._invalidate()
    +
    + def _tokenize(self,
    + s,
    + add_sym_if_not_exists = True,
    + filename = None,
    + linenr = None):
    + """Returns a _Feed instance containing tokens derived from the string
    + 's'. Registers any new symbols encountered (via _sym_lookup()).
    +
    + (I experimented with a regular expression implementation, but it came
    + out 5% _slower_ and wouldn't have been as flexible).
    +
    + add_sym_if_not_exists -- False when we do not want to register new
    + symbols, such as when called from
    + Config.eval()."""
    + tokens = []
    + previous = None
    +
    + strlen = len(s)
    + append = tokens.append
    +
    + # The current index in the string being tokenized
    + i = 0
    +
    + while i < strlen:
    + c = s[i]
    +
    + if c.isspace():
    + i += 1
    + continue
    +
    + elif c == "=":
    + append(T_EQUAL)
    + i += 1
    +
    + elif c == "!":
    + if i + 1 >= strlen:
    + _tokenization_error(s, strlen, filename, linenr)
    + if s[i + 1] == "=":
    + append(T_UNEQUAL)
    + i += 2
    + else:
    + append(T_NOT)
    + i += 1
    +
    + elif c == "(":
    + append(T_OPEN_PAREN)
    + i += 1
    +
    + elif c == ")":
    + append(T_CLOSE_PAREN)
    + i += 1
    +
    + elif c == "&":
    + if i + 1 >= strlen:
    + _tokenization_error(s, strlen, filename, linenr)
    + if s[i + 1] != "&":
    + _tokenization_error(s, i + 1, filename, linenr)
    + append(T_AND)
    + i += 2
    +
    + elif c == "|":
    + if i + 1 >= strlen:
    + _tokenization_error(s, strlen, filename, linenr)
    + if s[i + 1] != "|":
    + _tokenization_error(s, i + 1, filename, linenr)
    + append(T_OR)
    + i += 2
    +
    + elif c == '"' or c == "'":
    + quote = c
    + value = ""
    + i += 1
    + while True:
    + if i >= strlen:
    + _tokenization_error(s, strlen, filename, linenr)
    + c = s[i]
    + if c == quote:
    + break
    + elif c == "\\":
    + if i + 1 >= strlen:
    + _tokenization_error(s, strlen, filename, linenr)
    + value += s[i + 1]
    + i += 2
    + else:
    + value += c
    + i += 1
    + i += 1
    + append(value)
    +
    + elif c == "#":
    + break
    +
    + else: # Symbol or keyword
    + name_start = i
    +
    + # Locate the end of the symbol/keyword
    + i += 1
    + while i < strlen and s[i] in sym_chars:
    + i += 1
    +
    + name = s[name_start:i]
    +
    + keyword = keywords.get(name)
    +
    + if keyword is not None:
    + append(keyword)
    + # What would ordinarily be considered a name is treated as a
    + # string after certain tokens.
    + elif previous in string_lex:
    + append(name)
    + else:
    + # We're dealing with a symbol. _sym_lookup() will take care
    + # of allocating a new Symbol instance if it's the first
    + # time we see it.
    + sym = self._sym_lookup(name, add_sym_if_not_exists)
    +
    + if previous == T_CONFIG:
    + # If the previous token is T_CONFIG ("config"), we're
    + # tokenizing the first line of a symbol definition, and
    + # should remember this as a location where the symbol
    + # is defined.
    + sym.def_locations.append((filename, linenr))
    + else:
    + # Otherwise, it's a reference to the symbol
    + sym.ref_locations.append((filename, linenr))
    +
    + append(sym)
    +
    + previous = tokens[-1]
    +
    + return _Feed(tokens)
    +
    + #
    + # Parsing
    + #
    +
    + # Expression grammar:
    + #
    + # <expr> -> <symbol>
    + # <symbol> '=' <symbol>
    + # <symbol> '!=' <symbol>
    + # '(' <expr> ')'
    + # '!' <expr>
    + # <expr> '&&' <expr>
    + # <expr> '||' <expr>
    +
    + def _parse_expr(self,
    + feed,
    + cur_sym_or_choice,
    + line,
    + filename = None,
    + linenr = None,
    + transform_m = True):
    + """Parse an expression from the tokens in 'feed' using a simple
    + top-down approach. The result has the form (<operator>, <list
    + containing parsed operands>).
    +
    + feed -- _Feed instance containing the tokens for the expression.
    +
    + cur_sym_or_choice -- The symbol or choice currently being parsed, or
    + None if we're not parsing a symbol or choice.
    + Used for recording references to symbols.
    +
    + line -- The line containing the expression being parsed.
    +
    + filename (default: None) -- The file containing the expression.
    +
    + linenr (default: None) -- The line number containing the expression.
    +
    + transform_m (default: False) -- Determines if 'm' should be rewritten to
    + 'm && MODULES' -- see
    + parse_val_and_cond()."""
    +
    + # Use instance variables to avoid having to pass these as arguments
    + # through the top-down parser in _parse_expr_2(), which is tedious and
    + # obfuscates the code. A profiler run shows no noticeable performance
    + # difference.
    + self.parse_expr_cur_sym_or_choice = cur_sym_or_choice
    + self.parse_expr_line = line
    + self.parse_expr_filename = filename
    + self.parse_expr_linenr = linenr
    + self.parse_expr_transform_m = transform_m
    +
    + return self._parse_expr_2(feed)
    +
    + def _parse_expr_2(self, feed):
    + or_terms = [self._parse_or_term(feed)]
    + # Keep parsing additional terms while the lookahead is '||'
    + while feed.check(T_OR):
    + or_terms.append(self._parse_or_term(feed))
    +
    + if len(or_terms) == 1:
    + return or_terms[0]
    + else:
    + return (OR, or_terms)
    +
    + def _parse_or_term(self, feed):
    + and_terms = [self._parse_factor(feed)]
    + # Keep parsing additional terms while the lookahead is '&&'
    + while feed.check(T_AND):
    + and_terms.append(self._parse_factor(feed))
    +
    + if len(and_terms) == 1:
    + return and_terms[0]
    + else:
    + return (AND, and_terms)
    +
    + def _parse_factor(self, feed):
    + if feed.check(T_OPEN_PAREN):
    + expr_parse = self._parse_expr_2(feed)
    +
    + if not feed.check(T_CLOSE_PAREN):
    + _parse_error(self.parse_expr_line,
    + "missing end parenthesis.",
    + self.parse_expr_filename,
    + self.parse_expr_linenr)
    +
    + return expr_parse
    +
    + if feed.check(T_NOT):
    + return (NOT, self._parse_factor(feed))
    +
    + sym_or_string = feed.get_next()
    +
    + if not isinstance(sym_or_string, (Symbol, str)):
    + _parse_error(self.parse_expr_line,
    + "malformed expression.",
    + self.parse_expr_filename,
    + self.parse_expr_linenr)
    +
    + if self.parse_expr_cur_sym_or_choice is not None and \
    + isinstance(sym_or_string, Symbol):
    + self.parse_expr_cur_sym_or_choice.referenced_syms.add(sym_or_string)
    +
    + if feed.peek_next() not in (T_EQUAL, T_UNEQUAL):
    + if self.parse_expr_transform_m and (sym_or_string is self.m or
    + sym_or_string == "m"):
    + return (AND, ["m", self._sym_lookup("MODULES")])
    + return sym_or_string
    +
    + relation = EQUAL if (feed.get_next() == T_EQUAL) else UNEQUAL
    + sym_or_string_2 = feed.get_next()
    +
    + if sym_or_string is self.m:
    + sym_or_string = "m"
    +
    + if sym_or_string_2 is self.m:
    + sym_or_string_2 = "m"
    +
    + return (relation, sym_or_string, sym_or_string_2)
    +
    + def _parse_file(self, filename, parent, deps, visible_if_deps):
    + """Parse the Kconfig file 'filename'. The result is
    + a _Block with all items from the file."""
    + line_feeder = _FileFeed(_get_lines(filename), filename)
    + return self._parse_block(line_feeder, None, parent, deps, visible_if_deps)
    +
    + def _parse_block(self, line_feeder, end_marker, parent, deps, visible_if_deps = None):
    + """Parses a block, which is the contents of either a file or an if,
    + menu, or choice statement.
    +
    + end_marker -- The token that ends the block, e.g. T_ENDIF ("endif") for
    + if's. None for files.
    +
    + parent -- The enclosing menu, choice or if, or None if we're at the top
    + level.
    +
    + deps -- Dependencies from enclosing menus, choices and if's.
    +
    + visible_if_deps (default: None) -- 'visible if' dependencies from
    + enclosing menus."""
    +
    + block = _Block()
    +
    + filename = line_feeder.get_filename()
    +
    + while True:
    +
    + # Do we already have a tokenized line that we determined wasn't
    + # part of whatever we were parsing earlier? See comment in
    + # Config.__init__().
    + if self.end_line is not None:
    + assert self.end_line_tokens is not None
    + tokens = self.end_line_tokens
    + tokens.go_to_start()
    +
    + line = self.end_line
    + linenr = line_feeder.get_linenr()
    +
    + self.end_line = None
    + self.end_line_tokens = None
    +
    + else:
    + line = line_feeder.get_next()
    + if line is None:
    + if end_marker is not None:
    + raise Kconfig_Syntax_Error, (
    + "Unexpected end of file {0}."
    + .format(line_feeder.get_filename()))
    + return block
    +
    + linenr = line_feeder.get_linenr()
    +
    + tokens = self._tokenize(line, True, filename, linenr)
    +
    + if tokens.is_empty():
    + continue
    +
    + t0 = tokens.get_next()
    +
    + # Have we reached the end of the block?
    + if t0 == end_marker:
    + return block
    +
    + elif 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()
    +
    + # 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
    +
    + self.kconfig_syms.append(sym)
    + block.add_item(sym)
    +
    + self._parse_properties(line_feeder, sym, deps, visible_if_deps)
    +
    + elif t0 == T_MENU:
    + menu = Menu()
    + menu.config = self
    + menu.parent = parent
    + menu.title = tokens.get_next()
    +
    + menu.filename = filename
    + menu.linenr = linenr
    +
    + # Parse properties and contents
    + self._parse_properties(line_feeder, menu, deps, visible_if_deps)
    + menu.block = self._parse_block(line_feeder,
    + T_ENDMENU,
    + menu,
    + menu.dep_expr,
    + self._make_and(visible_if_deps,
    + menu.visible_if_expr))
    +
    + block.add_item(menu)
    + self.menus.append(menu)
    +
    + 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, filename, linenr)
    + if_block = self._parse_block(line_feeder,
    + T_ENDIF,
    + parent,
    + self._make_and(dep_expr, deps),
    + visible_if_deps)
    +
    + block.add_items_from_block(if_block)
    +
    + elif t0 == T_CHOICE:
    + # We support named choices
    + already_defined = False
    + name = None
    + if len(tokens) > 1 and isinstance(tokens[1], str):
    + name = tokens[1]
    + already_defined = name in self.named_choices
    +
    + if already_defined:
    + choice = self.named_choices[name]
    + else:
    + choice = Choice()
    + if name is not None:
    + choice.name = name
    + self.named_choices[name] = choice
    +
    + choice.config = self
    +
    + choice.def_locations.append((filename, linenr))
    +
    + # Parse properties and contents
    + self._parse_properties(line_feeder, choice, deps, visible_if_deps)
    + choice.block = self._parse_block(line_feeder,
    + T_ENDCHOICE,
    + choice,
    + None,
    + visible_if_deps)
    +
    + choice._determine_actual_items()
    +
    + # If no type is set for the choice, its type is that of the first
    + # choice item
    + if choice.type == UNKNOWN:
    + for item in choice.get_actual_items():
    + if item.get_type() != UNKNOWN:
    + choice.type = item.get_type()
    + break
    +
    + # Each choice item of UNKNOWN type gets the type of the choice
    + for item in choice.get_actual_items():
    + if item.type == UNKNOWN:
    + item.type = choice.type
    +
    + # For named choices defined in multiple locations, only record
    + # at the first definition
    + if not already_defined:
    + block.add_item(choice)
    + self.choices.append(choice)
    +
    + elif t0 == T_COMMENT:
    + comment = Comment()
    + comment.config = self
    + comment.parent = parent
    +
    + comment.filename = filename
    + comment.linenr = linenr
    +
    + comment.text = tokens.get_next()
    + self._parse_properties(line_feeder, comment, deps, visible_if_deps)
    +
    + block.add_item(comment)
    + self.comments.append(comment)
    +
    + elif t0 == T_SOURCE:
    + kconfig_file = tokens.get_next()
    + f = os.path.join(self.base_dir, os.path.expandvars(kconfig_file))
    +
    + if not os.path.exists(f):
    + raise IOError, ('{0}:{1}: sourced file "{2}" not found. Perhaps '
    + 'base_dir (argument to Config.__init__(), currently '
    + '"{3}") is set to the wrong value.'
    + .format(filename,
    + linenr,
    + kconfig_file,
    + self.base_dir))
    +
    + file_block = self._parse_file(f, parent, deps, visible_if_deps)
    + block.add_items_from_block(file_block)
    +
    + elif t0 == T_MAINMENU:
    + text = tokens.get_next()
    +
    + if self.mainmenu_text is not None:
    + self._warn("overriding 'mainmenu' text. "
    + 'Old value: "{0}", new value: "{1}".'
    + .format(self.mainmenu_text, text),
    + filename,
    + linenr)
    +
    + self.mainmenu_text = os.path.expandvars(text)
    +
    + else:
    + _parse_error(line, "unrecognized construct.", filename, linenr)
    +
    + def _parse_properties(self, line_feeder, stmt, deps, visible_if_deps):
    + """Parsing of properties for symbols, menus, choices, and comments."""
    +
    + def parse_val_and_cond(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."""
    + val = self._parse_expr(tokens, stmt, line, filename, linenr, False)
    +
    + if tokens.check(T_IF):
    + return (val, self._parse_expr(tokens, stmt, line, filename, linenr))
    +
    + return (val, None)
    +
    + # In case the symbol is defined in multiple locations, we need to
    + # remember what prompts, defaults, and selects are new for this
    + # definition, as "depends on" should only apply to the local
    + # definition.
    + new_prompt = None
    + new_def_exprs = []
    + new_selects = []
    +
    + # Dependencies from 'depends on' statements
    + depends_on_expr = None
    +
    + while True:
    + line = line_feeder.get_next()
    + if line is None:
    + break
    +
    + filename = line_feeder.get_filename()
    + linenr = line_feeder.get_linenr()
    +
    + tokens = self._tokenize(line, True, filename, linenr)
    +
    + if tokens.is_empty():
    + continue
    +
    + t0 = tokens.get_next()
    +
    + if t0 == T_HELP:
    + # Find first non-empty line and get its indentation
    +
    + line_feeder.remove_while(str.isspace)
    + line = line_feeder.get_next()
    +
    + if line is None:
    + stmt.help = ""
    + break
    +
    + indent = _indentation(line)
    +
    + # If the first non-empty lines has zero indent, there is no
    + # help text
    + if indent == 0:
    + stmt.help = ""
    + line_feeder.go_back()
    + break
    +
    + help_lines = [_deindent(line, indent)]
    +
    + # The help text goes on till the first non-empty line with less
    + # indent
    + while True:
    + line = line_feeder.get_next()
    + if (line is None) or \
    + (not line.isspace() and _indentation(line) < indent):
    + stmt.help = "".join(help_lines)
    + break
    +
    + help_lines.append(_deindent(line, indent))
    +
    + if line is None:
    + break
    +
    + line_feeder.go_back()
    +
    + 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 = parse_val_and_cond(tokens, line, filename, linenr)
    +
    + elif t0 == T_DEFAULT:
    + new_def_exprs.append(parse_val_and_cond(tokens, line, filename, linenr))
    +
    + elif t0 == T_DEPENDS:
    + if not tokens.check(T_ON):
    + _parse_error(line, 'expected "on" after "depends".', filename, linenr)
    +
    + parsed_deps = self._parse_expr(tokens, stmt, line, filename, linenr)
    +
    + if isinstance(stmt, (Menu, Comment)):
    + stmt.dep_expr = self._make_and(stmt.dep_expr, parsed_deps)
    + else:
    + depends_on_expr = self._make_and(depends_on_expr, parsed_deps)
    +
    + elif t0 == T_VISIBLE:
    + 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)
    +
    + parsed_deps = self._parse_expr(tokens, stmt, line, filename, linenr)
    + stmt.visible_if_expr = self._make_and(stmt.visible_if_expr, parsed_deps)
    +
    + elif t0 == T_SELECT:
    + target = tokens.get_next()
    +
    + stmt.referenced_syms.add(target)
    + stmt.selected_syms.add(target)
    +
    + if tokens.check(T_IF):
    + new_selects.append((target,
    + self._parse_expr(tokens, stmt, line, filename, linenr)))
    + else:
    + new_selects.append((target, None))
    +
    + elif t0 in (T_BOOL, T_TRISTATE, T_INT, T_HEX, T_STRING):
    + stmt.type = token_to_type[t0]
    +
    + if len(tokens) > 1:
    + new_prompt = parse_val_and_cond(tokens, line, filename, linenr)
    +
    + elif t0 == T_RANGE:
    + lower = tokens.get_next()
    + upper = tokens.get_next()
    +
    + if tokens.check(T_IF):
    + stmt.ranges.append((lower, upper,
    + self._parse_expr(tokens, stmt, line, filename, linenr)))
    + else:
    + stmt.ranges.append((lower, upper, None))
    +
    + elif t0 == T_DEF_BOOL:
    + stmt.type = BOOL
    +
    + if len(tokens) > 1:
    + new_def_exprs.append(parse_val_and_cond(tokens, line, filename, linenr))
    +
    + elif t0 == T_DEF_TRISTATE:
    + stmt.type = TRISTATE
    +
    + if len(tokens) > 1:
    + new_def_exprs.append(parse_val_and_cond(tokens, line, filename, linenr))
    +
    + elif t0 == T_OPTIONAL:
    + if not isinstance(stmt, Choice):
    + _parse_error(line,
    + '"optional" is only valid for choices.',
    + filename,
    + linenr)
    + stmt.optional = True
    +
    + elif t0 == T_OPTION:
    + if tokens.check(T_ENV) and tokens.check(T_EQUAL):
    + env_var = tokens.get_next()
    +
    + stmt.is_special_ = True
    + stmt.is_from_env = True
    +
    + if env_var not in os.environ:
    + self._warn("""
    +The symbol {0} references the non-existent environment variable {1} and will
    +get the empty string as its value. You could set it in os.environ before
    +calling Config() or make sure it is exported before invoking the script by
    +running e.g.
    +
    +$ export {1}=<value>
    +$ python foo.py
    +
    +or
    +
    +$ {1}=<value> python foo.py
    +
    +If you're using kconfiglib via 'make 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 e-mail kconfiglib@gmail.com.
    +.""" .format(stmt.get_name(), env_var),
    + filename,
    + linenr)
    +
    + stmt.cached_value = ""
    + else:
    + stmt.cached_value = os.environ[env_var]
    +
    + elif tokens.check(T_DEFCONFIG_LIST):
    + self.defconfig_sym = stmt
    +
    + elif tokens.check(T_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.",
    + filename,
    + linenr)
    +
    + else:
    + _parse_error(line, "unrecognized option.", filename, linenr)
    +
    + else:
    + # See comment in Config.__init__()
    + self.end_line = line
    + self.end_line_tokens = tokens
    + break
    +
    + # Propagate dependencies from enclosing menus and if's.
    +
    + # For menus and comments..
    + if isinstance(stmt, (Menu, Comment)):
    + stmt.orig_deps = stmt.dep_expr
    + stmt.deps_from_containing = deps
    + stmt.dep_expr = self._make_and(stmt.dep_expr, deps)
    +
    + stmt.all_referenced_syms = \
    + stmt.referenced_syms.union(self._get_expr_syms(deps))
    +
    + # For symbols and choices..
    + else:
    +
    + # See comment for 'menu_dep'
    + stmt.menu_dep = depends_on_expr
    +
    + # Propagate dependencies specified with 'depends on' to any new
    + # default expressions, prompts, and selections ("new" since a
    + # symbol might be defined in multiple places and the dependencies
    + # should only apply to the local definition).
    +
    + new_def_exprs = [(val_expr, self._make_and(cond_expr, depends_on_expr))
    + for (val_expr, cond_expr) in new_def_exprs]
    +
    + new_selects = [(target, self._make_and(cond_expr, depends_on_expr))
    + for (target, cond_expr) in new_selects]
    +
    + if new_prompt is not None:
    + prompt, cond_expr = new_prompt
    +
    + # 'visible if' dependencies from enclosing menus get propagated
    + # to prompts
    + if visible_if_deps is not None:
    + cond_expr = self._make_and(cond_expr, visible_if_deps)
    +
    + new_prompt = (prompt, self._make_and(cond_expr, depends_on_expr))
    +
    + # We save the original expressions -- before any menu and if
    + # conditions have been propagated -- so these can be retrieved
    + # later.
    +
    + stmt.orig_def_exprs.extend(new_def_exprs)
    + if new_prompt is not None:
    + stmt.orig_prompts.append(new_prompt)
    +
    + # Only symbols can select
    + if isinstance(stmt, Symbol):
    + stmt.orig_selects.extend(new_selects)
    +
    + # Save dependencies from enclosing menus and if's
    + stmt.deps_from_containing = deps
    +
    + # The set of symbols referenced directly by the symbol/choice plus
    + # all symbols referenced by enclosing menus and if's.
    + stmt.all_referenced_syms \
    + = stmt.referenced_syms.union(self._get_expr_syms(deps))
    +
    + # Propagate dependencies from enclosing menus and if's
    +
    + stmt.def_exprs.extend([(val_expr, self._make_and(cond_expr, deps))
    + for (val_expr, cond_expr) in new_def_exprs])
    +
    + for (target, cond) in new_selects:
    + target.rev_dep = self._make_or(target.rev_dep,
    + self._make_and(stmt,
    + self._make_and(cond, deps)))
    +
    + if new_prompt is not None:
    + prompt, cond_expr = new_prompt
    + stmt.prompts.append((prompt, self._make_and(cond_expr, deps)))
    +
    + #
    + # Symbol table manipulation
    + #
    +
    + def _sym_lookup(self, name, add_sym_if_not_exists = True):
    + """Fetches the symbol 'name' from the symbol table, optionally adding
    + it if it does not exist (this is usually what we want)."""
    + if name in self.syms:
    + return self.syms[name]
    +
    + new_sym = Symbol()
    + new_sym.config = self
    + new_sym.name = name
    +
    + if add_sym_if_not_exists:
    + self.syms[name] = new_sym
    + else:
    + # This warning is generated while evaluating an expression
    + # containing undefined symbols using Config.eval()
    + self._warn("no symbol {0} in configuration".format(name))
    +
    + return new_sym
    +
    + #
    + # Evaluation of symbols and expressions
    + #
    +
    + def _eval_expr(self, expr):
    + """Evaluates an expression and returns one of the tristate values "n",
    + "m" or "y"."""
    + res = self._eval_expr_2(expr)
    +
    + # 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 false if
    + # we're running without modules.
    + if res == "m" and not self._has_modules():
    + return "y"
    +
    + return res
    +
    + def _eval_expr_2(self, expr):
    + if expr is None:
    + return "y"
    +
    + if isinstance(expr, (str, Symbol)):
    + val = self._get_str_value(expr)
    + # Expressions always have a tristate value
    + return val if val in ("y", "m") else "n"
    +
    + first_expr = expr[0]
    +
    + if first_expr == OR:
    + res = "n"
    +
    + for subexpr in expr[1]:
    + ev = self._eval_expr_2(subexpr)
    +
    + # Return immediately upon discovering a "y" term
    + if ev == "y":
    + return "y"
    +
    + if ev == "m":
    + res = "m"
    +
    + # 'res' is either "n" or "m" here; we already handled the
    + # short-circuiting "y" case in the loop.
    + return res
    +
    + if first_expr == AND:
    + res = "y"
    +
    + for subexpr in expr[1]:
    + ev = self._eval_expr_2(subexpr)
    +
    + # Return immediately upon discovering an "n" term
    + if ev == "n":
    + return "n"
    +
    + if ev == "m":
    + res = "m"
    +
    + # 'res' is either "m" or "y" here; we already handled the
    + # short-circuiting "n" case in the loop.
    + return res
    +
    + if first_expr == NOT:
    + ev = self._eval_expr_2(expr[1])
    +
    + if ev == "y":
    + return "n"
    +
    + return "y" if (ev == "n") else "m"
    +
    + if first_expr in (EQUAL, UNEQUAL):
    + _, sym_or_str_1, sym_or_str_2 = expr
    +
    + val_1 = self._get_str_value(sym_or_str_1)
    + val_2 = self._get_str_value(sym_or_str_2)
    +
    + if (first_expr == EQUAL and val_1 == val_2) or \
    + (first_expr == UNEQUAL and val_1 != val_2):
    +
    + return "y"
    +
    + return "n"
    +
    + _internal_error("Internal error while evaluating expression with token stream {0}: "
    + "unknown type {0}."
    + .format(expr))
    +
    + def _eval_to_int(self, expr):
    + return values[self._eval_expr(expr)]
    +
    + def _get_str_value(self, obj):
    + if isinstance(obj, str):
    + return obj
    +
    + # obj is a Symbol
    + return obj.calc_value()
    +
    + def _eval_min(self, e1, e2):
    + 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):
    + 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
    +
    + #
    + # Construction of expressions
    + #
    +
    + # These functions as well as the _eval_min/max() functions above equate
    + # None with "y", which is usually what we want, but needs to be kept in
    + # mind.
    +
    + def _make_or(self, e1, e2):
    + # Perform trivial simplification and avoid None's (which
    + # correspond to y's)
    + if "y" in (e1, e2) or None in (e1, e2):
    + return "y"
    +
    + if e1 == "n":
    + return e2
    +
    + if e2 == "n":
    + return e1
    +
    + # Prefer to merge/update argument list if possible instead of creating
    + # a new OR node
    +
    + if isinstance(e1, tuple) and e1[0] == OR:
    + if isinstance(e2, tuple) and e2[0] == OR:
    + return (OR, e1[1] + e2[1])
    + else:
    + return (OR, e1[1] + [e2])
    +
    + if isinstance(e2, tuple) and e2[0] == OR:
    + return (OR, e2[1] + [e1])
    +
    + return (OR, [e1, e2])
    +
    + # Note: returns None if e1 == e2 == None
    +
    + def _make_and(self, e1, e2):
    + if "n" in (e1, e2):
    + return "n"
    +
    + if e1 in (None, "y"):
    + return e2
    +
    + if e2 in (None, "y"):
    + return e1
    +
    + # Prefer to merge/update argument list if possible instead of creating
    + # a new AND node
    +
    + if isinstance(e1, tuple) and e1[0] == AND:
    + if isinstance(e2, tuple) and e2[0] == AND:
    + return (AND, e1[1] + e2[1])
    + else:
    + return (AND, e1[1] + [e2])
    +
    + if isinstance(e2, tuple) and e2[0] == AND:
    + return (AND, e2[1] + [e1])
    +
    + return (AND, [e1, e2])
    +
    + #
    + # Methods related to the MODULES symbol
    + #
    +
    + def _has_modules(self):
    + modules_sym = self.syms.get("MODULES")
    + return (modules_sym is not None) and (modules_sym.calc_value() == "y")
    +
    + #
    + # Dependency tracking
    + #
    +
    + def _build_dep(self):
    + """Populates the dep dictionary, linking a symbol to the symbols that
    + immediately depend on it."""
    + for sym in self.syms.itervalues():
    + self.dep[sym] = set()
    +
    + def add_expr_deps(e, sym):
    + for s in self._get_expr_syms(e):
    + self.dep[s].add(sym)
    +
    + # The directly dependent symbols of a symbol are:
    + # - Any symbols whose prompt or default value depends on the symbol
    + # - Any symbols whose rev_dep (select condition) depends on the symbol
    + # - Any symbols that belong to the same choice statement as the symbol
    + # (these won't be included in 'dep' as that makes the dependency
    + # graph unwieldy, but Symbol._get_dependent() will include them)
    + # - Any symbols in a choice statement that depends on the symbol
    + for sym in self.syms.itervalues():
    + for (_, e) in sym.prompts:
    + add_expr_deps(e, sym)
    +
    + for (v, e) in sym.def_exprs:
    + add_expr_deps(v, sym)
    + add_expr_deps(e, sym)
    +
    + add_expr_deps(sym.rev_dep, sym)
    +
    + if sym.is_choice_item():
    + choice = sym.parent
    +
    + for (_, e) in choice.prompts:
    + add_expr_deps(e, sym)
    +
    + for (_, e) in choice.def_exprs:
    + add_expr_deps(e, sym)
    +
    + def _get_expr_syms(self, expr):
    + """Returns the set() of symbols appearing in expr."""
    + if expr is None or isinstance(expr, str):
    + return set()
    +
    + if isinstance(expr, Symbol):
    + return set((expr,))
    +
    + elif expr[0] in (OR, AND):
    + res = set()
    + for subres in [self._get_expr_syms(e) for e in expr[1]]:
    + res.update(subres)
    + return res
    +
    + elif expr[0] == NOT:
    + return self._get_expr_syms(expr[1])
    +
    + elif expr[0] in (EQUAL, UNEQUAL):
    + res = set()
    +
    + (_, v1, v2) = expr
    +
    + if isinstance(v1, Symbol):
    + res.add(v1)
    +
    + if isinstance(v2, Symbol):
    + res.add(v2)
    +
    + return res
    +
    + else:
    + _internal_error("Internal error while fetching symbols from an expression with "
    + "token stream {0}.".format(expr))
    +
    + def _expr_val_str(self, expr, no_value_str = "(none)", get_val_instead_of_eval = False):
    + # Since values are valid expressions, _expr_to_str() will get a nice
    + # string representation for those as well.
    +
    + 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.calc_value()
    + else:
    + val = self._eval_expr(expr)
    +
    + return "{0} (value: {1})".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_value_str = "(no user value)" if sc.user_val is None else s(sc.user_val)
    +
    + visibility_str = s(sc.get_visibility())
    +
    + # Build prompts string
    + if sc.prompts == []:
    + prompts_str = " (no prompts)"
    + else:
    + prompts_str_rows = []
    +
    + for (prompt, cond_expr) in sc.orig_prompts:
    + if cond_expr is None:
    + prompts_str_rows.append(' "{0}"'.format(prompt))
    + else:
    + prompts_str_rows.append(' "{0}" if '.format(prompt) +
    + self._expr_val_str(cond_expr))
    +
    + prompts_str = "\n".join(prompts_str_rows)
    +
    + # Build locations string
    + if sc.def_locations == []:
    + locations_str = "(no locations)"
    + else:
    + locations_str = " ".join(["{0}:{1}".format(filename, linenr) for
    + (filename, linenr) in sc.def_locations])
    +
    + # Build additional-dependencies-from-menus-and-if's string
    + additional_deps_str = " " + self._expr_val_str(sc.deps_from_containing,
    + "(no additional dependencies)")
    +
    + #
    + # Symbol-specific stuff
    + #
    +
    + if isinstance(sc, Symbol):
    +
    + # Build value string
    + value_str = s(sc.calc_value())
    +
    + # Build ranges string
    + if isinstance(sc, Symbol):
    + if sc.ranges == []:
    + ranges_str = " (no ranges)"
    + else:
    + ranges_str_rows = []
    +
    + for (l, u, cond_expr) in sc.ranges:
    + if cond_expr is None:
    + ranges_str_rows.append(" [{0}, {1}]".format(s(l), s(u)))
    + else:
    + ranges_str_rows.append(" [{0}, {1}] if {2}"
    + .format(s(l), s(u), self._expr_val_str(cond_expr)))
    +
    + ranges_str = "\n".join(ranges_str_rows)
    +
    + # Build default values string
    + if sc.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.get_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 sc.orig_selects == []:
    + selects_str = " (no selects)"
    + else:
    + selects_str_rows = []
    +
    + for (target, cond_expr) in sc.orig_selects:
    + if cond_expr is None:
    + selects_str_rows.append(" {0}".format(target.name))
    + else:
    + selects_str_rows.append(" {0} if ".format(target.name) +
    + self._expr_val_str(cond_expr))
    +
    + selects_str = "\n".join(selects_str_rows)
    +
    + # Build reverse dependencies string
    + if sc.rev_dep == "n":
    + rev_dep_str = " (no reverse dependencies)"
    + else:
    + rev_dep_str = " " + self._expr_val_str(sc.rev_dep)
    +
    + res = _sep_lines("Symbol " + (sc.name if sc.name is not None else "(no name)"),
    + "Type : " + typename[sc.type],
    + "Value : " + value_str,
    + "User value : " + user_value_str,
    + "Visibility : " + visibility_str,
    + "Is choice item : " + bool_str[sc.is_choice_item()],
    + "Is defined : " + bool_str[sc.is_defined_],
    + "Is from env. : " + bool_str[sc.is_from_environment()],
    + "Is special : " + bool_str[sc.is_special_] + "\n")
    +
    + if sc.has_ranges():
    + res += _sep_lines("Ranges:",
    + ranges_str + "\n")
    +
    + res += _sep_lines("Prompts:",
    + prompts_str,
    + "Default values:",
    + defaults_str,
    + "Selects:",
    + selects_str,
    + "Reverse dependencies:",
    + rev_dep_str,
    + "Additional dependencies from enclosing menus and if's:",
    + additional_deps_str,
    + "Locations: " + locations_str)
    +
    + return res
    +
    + #
    + # Choice-specific stuff
    + #
    +
    + # Build name string (for named choices)
    + if sc.get_name() is None:
    + name_str = "(no name)"
    + else:
    + name_str = sc.get_name()
    +
    + # Build selected symbol string
    + sel = sc.get_selection()
    + if sel is None:
    + sel_str = "(no selection)"
    + else:
    + sel_str = sel.get_name()
    +
    + # Build mode string
    + mode_str = s(sc.calc_mode())
    +
    + # Build default values string
    + if sc.def_exprs == []:
    + defaults_str = " (no default values)"
    + else:
    + defaults_str_rows = []
    +
    + for (sym, cond_expr) in sc.orig_def_exprs:
    + if cond_expr is None:
    + defaults_str_rows.append(" {0}".format(sym.get_name()))
    + else:
    + defaults_str_rows.append(" {0} if ".format(sym.get_name()) +
    + self._expr_val_str(cond_expr))
    +
    + defaults_str = "\n".join(defaults_str_rows)
    +
    + # Build contained symbols string
    + names = [sym.get_name() for sym in sc.get_actual_items()]
    +
    + if names == []:
    + syms_string = "(empty)"
    + else:
    + syms_string = " ".join(names)
    +
    + return _sep_lines("Choice",
    + "Name (for named choices): " + name_str,
    + "Type : " + typename[sc.type],
    + "Selected symbol : " + sel_str,
    + "User value : " + user_value_str,
    + "Mode : " + mode_str,
    + "Visibility : " + visibility_str,
    + "Optional : " + bool_str[sc.optional],
    + "Prompts:",
    + prompts_str,
    + "Defaults:",
    + defaults_str,
    + "Choice symbols:",
    + " " + syms_string,
    + "Additional dependencies from enclosing menus and if's:",
    + additional_deps_str,
    + "Locations: " + locations_str)
    +
    + 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:
    + for and_expr in expr[1]:
    + if rec(and_expr):
    + return True
    +
    + return False
    +
    + return False
    +
    + return rec(expr)
    +
    + 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
    +
    + left = self._transform_n_m_y(left)
    + right = self._transform_n_m_y(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 _transform_n_m_y(self, item):
    + """_eq_to_sym() helper. Translates the symbols n, m, and y to their
    + string equivalents."""
    + if item is self.syms["n"]:
    + return "n"
    + if item is self.syms["m"]:
    + return "m"
    + if item is self.syms["y"]:
    + return "y"
    + return item
    +
    + def _warn(self, msg, filename = None, linenr = None):
    + """For printing warnings to stderr."""
    + if self.print_warnings:
    + self._warn_or_undef_assign(msg, WARNING, filename, linenr)
    +
    + def _undef_assign(self, msg, filename = None, linenr = None):
    + """For printing informational messages related to assignments
    + to undefined variables to stderr."""
    + if self.print_undef_assign:
    + self._warn_or_undef_assign(msg, UNDEF_ASSIGN, filename, linenr)
    +
    + def _warn_or_undef_assign(self, msg, msg_type, filename, linenr):
    + if filename is not None:
    + sys.stderr.write("{0}:".format(_clean_up_path(filename)))
    + if linenr is not None:
    + sys.stderr.write("{0}:".format(linenr))
    +
    + if msg_type == WARNING:
    + sys.stderr.write("warning: ")
    + elif msg_type == UNDEF_ASSIGN:
    + sys.stderr.write("info: ")
    + else:
    + _internal_error('Internal error while printing warning: unknown warning type "{0}".'
    + .format(msg_type))
    +
    + sys.stderr.write(msg + "\n")
    +
    +#
    +# Constants and functions related to types, parsing, evaluation and printing,
    +# put globally to unclutter the Config class a bit.
    +#
    +
    +# Tokens
    +(T_OR, T_AND, T_NOT,
    + T_OPEN_PAREN, T_CLOSE_PAREN,
    + T_EQUAL, T_UNEQUAL,
    + T_MAINMENU, T_MENU, T_ENDMENU,
    + T_SOURCE, T_CHOICE, T_ENDCHOICE,
    + T_COMMENT, T_CONFIG, T_MENUCONFIG,
    + T_HELP, T_IF, T_ENDIF, T_DEPENDS, T_ON,
    + T_OPTIONAL, T_PROMPT, T_DEFAULT,
    + T_BOOL, T_TRISTATE, T_HEX, T_INT, T_STRING,
    + T_DEF_BOOL, T_DEF_TRISTATE,
    + T_SELECT, T_RANGE, T_OPTION, T_ENV,
    + T_DEFCONFIG_LIST, T_MODULES, T_VISIBLE) = range(0, 38)
    +
    +# Keyword to token map
    +keywords = {
    + "mainmenu" : T_MAINMENU,
    + "menu" : T_MENU,
    + "endmenu" : T_ENDMENU,
    + "endif" : T_ENDIF,
    + "endchoice" : T_ENDCHOICE,
    + "source" : T_SOURCE,
    + "choice" : T_CHOICE,
    + "config" : T_CONFIG,
    + "comment" : T_COMMENT,
    + "menuconfig" : T_MENUCONFIG,
    + "help" : T_HELP,
    + "---help---" : T_HELP,
    + "---" : T_HELP, # Hack to handle CONFIG_W1_CON
    + "if" : T_IF,
    + "depends" : T_DEPENDS,
    + "on" : T_ON,
    + "optional" : T_OPTIONAL,
    + "prompt" : T_PROMPT,
    + "default" : T_DEFAULT,
    + "bool" : T_BOOL,
    + "boolean" : T_BOOL,
    + "tristate" : T_TRISTATE,
    + "int" : T_INT,
    + "hex" : T_HEX,
    + "def_bool" : T_DEF_BOOL,
    + "def_tristate" : T_DEF_TRISTATE,
    + "string" : T_STRING,
    + "select" : T_SELECT,
    + "range" : T_RANGE,
    + "option" : T_OPTION,
    + "env" : T_ENV,
    + "defconfig_list" : T_DEFCONFIG_LIST,
    + "modules" : T_MODULES,
    + "visible" : T_VISIBLE }
    +
    +# Strings to use for True and False
    +bool_str = { False : "false", True : "true" }
    +
    +# Tokens after which identifier-like lexemes are treated as strings. T_CHOICE
    +# is included to avoid symbols being registered for named choices.
    +string_lex = (T_BOOL, T_TRISTATE, T_INT, T_HEX, T_STRING,
    + T_CHOICE,
    + T_PROMPT,
    + T_MENU,
    + T_COMMENT,
    + T_SOURCE,
    + T_MAINMENU)
    +
    +# Characters that may appear in symbol names
    +sym_chars = frozenset(string.ascii_letters + string.digits + "._/-")
    +
    +# Regular expressions for parsing .config files
    +set_re = r"CONFIG_(\w+)=(.*)"
    +unset_re = r"# CONFIG_(\w+) is not set"
    +
    +# Integers representing symbol types
    +UNKNOWN, BOOL, TRISTATE, STRING, HEX, INT = range(0, 6)
    +
    +# Strings to use for types
    +typename = {
    + UNKNOWN : "unknown",
    + BOOL : "bool",
    + TRISTATE : "tristate",
    + STRING : "string",
    + HEX : "hex",
    + INT : "int" }
    +
    +# Token to type mapping
    +token_to_type = { T_BOOL : BOOL,
    + T_TRISTATE : TRISTATE,
    + T_STRING : STRING,
    + T_INT : INT,
    + T_HEX : HEX }
    +
    +# Default values for symbols of different types (the value the symbol gets if
    +# it is not assigned a user value and none of its 'default' clauses kick in)
    +default_value = { BOOL : "n",
    + TRISTATE : "n",
    + STRING : "",
    + INT : "",
    + HEX : "" }
    +
    +# Indicates that no item is selected in a choice statement
    +NO_SELECTION = 0
    +
    +# Integers representing expression types
    +OR, AND, NOT, EQUAL, UNEQUAL = range(0, 5)
    +
    +# Map from tristate values to integers
    +values = {"n" : 0, "m" : 1, "y" : 2}
    +
    +# Printing-related stuff
    +
    +op_to_str = { AND : " && ",
    + OR : " || ",
    + EQUAL : " = ",
    + UNEQUAL : " != " }
    +
    +precedence = {OR : 0, AND : 1, NOT : 2}
    +
    +# Types of informational messages
    +WARNING = 0
    +UNDEF_ASSIGN = 1
    +
    +def _intersperse(lst, op):
    + """_expr_to_str() helper. Gets the string representation of each expression in lst
    + and produces a list where op has been inserted between the elements."""
    + if lst == []:
    + return ""
    +
    + res = []
    +
    + def handle_sub_expr(expr):
    + no_parens = isinstance(expr, (str, Symbol)) or \
    + expr[0] in (EQUAL, UNEQUAL) or \
    + precedence[op] <= precedence[expr[0]]
    + if not no_parens:
    + res.append("(")
    + res.extend(_expr_to_str_rec(expr))
    + if not no_parens:
    + res.append(")")
    +
    + op_str = op_to_str[op]
    +
    + handle_sub_expr(lst[0])
    + for expr in lst[1:]:
    + res.append(op_str)
    + handle_sub_expr(expr)
    +
    + return res
    +
    +def _expr_to_str(expr):
    + s = "".join(_expr_to_str_rec(expr))
    + return s
    +
    +def _sym_str_string(sym_or_str):
    + if isinstance(sym_or_str, str):
    + return '"{0}"'.format(sym_or_str)
    + return sym_or_str.name
    +
    +def _expr_to_str_rec(expr):
    + if expr is None:
    + return [""]
    +
    + if isinstance(expr, (Symbol, str)):
    + return [_sym_str_string(expr)]
    +
    + if expr[0] in (OR, AND):
    + return _intersperse(expr[1], expr[0])
    +
    + if expr[0] == NOT:
    + need_parens = not isinstance(expr[1], (str, Symbol))
    +
    + res = ["!"]
    + if need_parens:
    + res.append("(")
    + res.extend(_expr_to_str_rec(expr[1]))
    + if need_parens:
    + res.append(")")
    + return res
    +
    + if expr[0] in (EQUAL, UNEQUAL):
    + return [_sym_str_string(expr[1]),
    + op_to_str[expr[0]],
    + _sym_str_string(expr[2])]
    +
    +class _Block:
    +
    + """Represents a list of items (symbols, menus, choice
    + statements and comments) appearing at the top-level of a
    + file or witin a menu, choice or if statement."""
    +
    + def __init__(self):
    + self.items = []
    +
    + def get_items(self):
    + return self.items
    +
    + def add_item(self, item):
    + self.items.append(item)
    +
    + def add_items_from_block(self, block):
    + self.items.extend(block.items)
    +
    + def _make_conf(self):
    + # Collect the substrings in a list and later use join() instead of +=
    + # to build the final .config contents. With older Python versions, this
    + # yields linear instead of quadratic complexity.
    + strings = []
    + for item in self.items:
    + strings.extend(item._make_conf())
    +
    + return strings
    +
    + def add_depend_expr(self, expr):
    + for item in self.items:
    + item.add_depend_expr(expr)
    +
    +class Item():
    +
    + """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, otherwise False. Short for
    + isinstance(item, kconfiglib.Symbol)."""
    + return isinstance(self, Symbol)
    +
    + def is_choice(self):
    + """Returns True if the item is a choice, otherwise False. Short for
    + isinstance(item, kconfiglib.Choice)."""
    + return isinstance(self, Choice)
    +
    + def is_menu(self):
    + """Returns True if the item is a menu, otherwise False. Short for
    + isinstance(item, kconfiglib.Menu)."""
    + return isinstance(self, Menu)
    +
    + def is_comment(self):
    + """Returns True if the item is a comment, otherwise False. Short for
    + isinstance(item, kconfiglib.Comment)."""
    + return isinstance(self, Comment)
    +
    +class _HasVisibility():
    +
    + """Base class for elements that have a "visibility" that acts as an upper
    + limit on the values a user can set for them. Subclasses are Symbol and
    + Choice."""
    +
    + def __init__(self):
    + self.cached_visibility = None
    + self.prompts = []
    +
    + def _invalidate(self):
    + self.cached_visibility = None
    +
    + def _calc_visibility(self):
    + if self.cached_visibility is None:
    + vis = "n"
    + for (prompt, cond_expr) in self.prompts:
    + vis = self.config._eval_max(vis, cond_expr)
    +
    + if isinstance(self, Symbol) and self.is_choice_item():
    + vis = self.config._eval_min(vis, self.parent._calc_visibility())
    +
    + # Promote "m" to "y" if we're dealing with a non-tristate
    + if vis == "m" and self.type != TRISTATE:
    + vis = "y"
    +
    + self.cached_visibility = vis
    +
    + return self.cached_visibility
    +
    +class Symbol(Item, _HasVisibility):
    +
    + """Represents a configuration symbol."""
    +
    + #
    + # Public interface
    + #
    +
    + def calc_value(self):
    + """Calculate and return the value of the symbol."""
    +
    + if self.cached_value is not None:
    + return self.cached_value
    +
    + self.write_to_conf = False
    +
    + # The following means that what to the user looks like a reference to
    + # an undefined symbol will actually get treated like a string whose
    + # value is the symbol name, which can be a bit unexpected.
    + if self.type == UNKNOWN:
    + self.cached_value = self.name
    + return self.name
    +
    + new_val = default_value[self.type]
    +
    + vis = self._calc_visibility()
    +
    + if self.type in (BOOL, TRISTATE):
    + # The visibility and mode (modules-only or single-selection) of
    + # choice items will be taken into account in self._calc_visibility()
    +
    + if self.is_choice_item():
    + if vis != "n":
    + choice = self.parent
    + mode = choice.calc_mode()
    +
    + self.write_to_conf = (mode != "n")
    +
    + if mode == "y":
    + new_val = "y" if (choice.get_selection() is self) else "n"
    + elif mode == "m":
    + if self.user_val in ("m", "y"):
    + new_val = "m"
    +
    + else:
    + use_defaults = True
    +
    + if vis != "n":
    + # If the symbol is visible and has a user value, use that.
    + # Otherwise, look at defaults.
    + self.write_to_conf = True
    +
    + if self.user_val is not None:
    + new_val = self.config._eval_min(self.user_val, vis)
    + use_defaults = False
    +
    + if use_defaults:
    + for (val_expr, cond_expr) in self.def_exprs:
    + cond_eval = self.config._eval_expr(cond_expr)
    +
    + if cond_eval != "n":
    + self.write_to_conf = True
    + new_val = self.config._eval_min(val_expr, cond_eval)
    + break
    +
    + # Reverse dependencies take precedence
    + rev_dep_val = self.config._eval_expr(self.rev_dep)
    +
    + if rev_dep_val != "n":
    + self.write_to_conf = True
    + new_val = self.config._eval_max(new_val, rev_dep_val)
    +
    + # Promote "m" to "y" for booleans
    + if new_val == "m" and self.type == BOOL:
    + new_val = "y"
    +
    + elif self.type == STRING:
    + use_defaults = True
    +
    + if vis != "n":
    + self.write_to_conf = True
    + if self.user_val is not None:
    + new_val = self.user_val
    + use_defaults = False
    +
    + if use_defaults:
    + for (val_expr, cond_expr) in self.def_exprs:
    + if self.config._eval_expr(cond_expr) != "n":
    + self.write_to_conf = True
    + new_val = self.config._get_str_value(val_expr)
    + break
    +
    + elif self.type in (HEX, INT):
    + active_range = None
    + use_defaults = True
    +
    + # TODO: HEX case should only accept hex and dec numbers
    +
    + for(l, u, cond_expr) in self.ranges:
    + if self.config._eval_expr(cond_expr) != "n":
    + l_str = self.config._get_str_value(l)
    + u_str = self.config._get_str_value(u)
    +
    + if self.type == INT:
    + if not _is_dec(l_str):
    + l_str = "0"
    +
    + if not _is_dec(u_str):
    + u_str = "0"
    +
    + active_range = (int(l_str), int(u_str))
    +
    + else: # self.type == HEX
    + if not _is_hex(l_str):
    + l_str = "0x0"
    +
    + if not _is_hex(u_str):
    + u_str = "0x0"
    +
    + active_range = (int(l_str, 16), int(u_str, 16))
    +
    + break
    +
    + if vis != "n":
    + self.write_to_conf = True
    +
    + if self.user_val is not None:
    + if self.type == INT:
    + if _is_dec(self.user_val):
    + num = int(self.user_val)
    + if active_range is None or \
    + active_range[0] <= num <= active_range[1]:
    +
    + use_defaults = False
    + new_val = self.user_val
    +
    + else: # HEX
    + if _is_hex(self.user_val):
    + num = int(self.user_val, 16)
    + if active_range is None or \
    + active_range[0] <= num <= active_range[1]:
    +
    + use_defaults = False
    + new_val = self.user_val
    +
    + if use_defaults:
    + for (val_expr, cond_expr) in self.def_exprs:
    + if self.config._eval_expr(cond_expr) != "n":
    + self.write_to_conf = True
    +
    + # Kconfig allows arbitrary string values for hex/int
    + # (possibly a bug, but we still emulate it).
    +
    + new_val = self.config._get_str_value(val_expr)
    +
    + if self.type == INT:
    + if _is_dec(new_val):
    + new_val_num = int(new_val)
    + elif self.type == HEX:
    + if _is_hex(new_val):
    + new_val_num = int(new_val, 16)
    +
    + if new_val_num is not None:
    + if active_range is not None:
    + l_num, u_num = active_range
    +
    + was_clamped = False
    +
    + if new_val_num < l_num:
    + new_val_num = l_num
    + was_clamped = True
    + elif new_val_num > u_num:
    + new_val_num = u_num
    + was_clamped = True
    +
    + if was_clamped:
    + new_val = (str(new_val_num) if self.type == INT else
    + hex(new_val_num))
    +
    + break
    +
    + self.cached_value = new_val
    + return new_val
    +
    + def calc_default_value(self):
    + """Calculates the value the symbol would get purely from defaults,
    + ignoring visibility (assumed to be "y"), reverse dependencies
    + (selects), user values and dependencies from enclosing menus and if's.
    + Returns None if no default would kick in."""
    + for (val_expr, cond_expr) in self.orig_def_exprs:
    + cond_eval = self.config._eval_expr(cond_expr)
    +
    + if cond_eval != "n":
    + return self.config._eval_expr(val_expr)
    +
    + return None
    +
    + def set_value(self, v):
    + """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() to find the range of valid values for bool and
    + tristate symbols; setting values outside this range will cause the user
    + value to differ from the result of Symbol.calc_value(). Any value that
    + is valid for the type (bool, tristate, etc.) will end up being
    + reflected in Symbol.get_user_value() though.
    +
    + Any symbols dependent on the symbol are (recursively) invalidated, so
    + things should just work with regards to dependencies.
    +
    + v -- The value to give to the symbol."""
    + self._set_value_no_invalidate(v, False)
    +
    + # There might be something more efficient you could do here, but play
    + # it safe.
    + if self.name == "MODULES":
    + self.config._invalidate_all()
    + return
    +
    + self._invalidate()
    + self._invalidate_dependent()
    +
    + def reset(self):
    + """Resets the value of the symbol, as if the symbol had never gotten a
    + (user) value via Config.load_config() or Symbol.set_value(). Dependent
    + symbols are recursively invalidated."""
    + self._reset_no_recursive_invalidate()
    + self._invalidate_dependent()
    +
    + def get_user_value(self):
    + """Returns the value assigned to the symbol in a .config or via
    + Symbol.set_value() (provided the value was valid for the type of the
    + symbol). Returns None in case of no user value."""
    + return self.user_val
    +
    + def get_name(self):
    + """Returns the name of the symbol."""
    + return self.name
    +
    + def get_upper_bound(self):
    + """Returns the highest value the symbol can be given via
    + Symbol.set_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 the 'make menuconfig' interface. Returns
    + None if the symbol is not visible (would not appear in the 'make
    + menuconfig' interface), or if the symbol's value cannot be changed (if
    + it is selected to "y", or to "m" if its visibility also happens to be
    + "m"). Also returns None for non-bool, non-tristate symbols and special
    + symbols.
    +
    + See also the tri_less*() and tri_greater*() functions, which could
    + come in handy here."""
    + if not self._is_assignable_bool_or_tristate():
    + return None
    +
    + return self._calc_visibility()
    +
    + def get_lower_bound(self):
    + """Returns the lowest value the symbol can be given via
    + Symbol.set_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 the 'make menuconfig' interface. Returns
    + None if the symbol is not visible (would not appear in the 'make
    + menuconfig' interface), or if the symbol's value cannot be changed (if
    + it is selected to "y", or to "m" if its visibility also happens to be
    + "m"). Also returns None for non-bool, non-tristate symbols and special
    + symbols.
    +
    + See also the tri_less*() and tri_greater*() functions, which could
    + come in handy here."""
    + if not self._is_assignable_bool_or_tristate():
    + return None
    +
    + return self.config._eval_expr(self.rev_dep)
    +
    + def get_assignable_values(self):
    + """For bool and tristate symbols, returns a list containing the values
    + the symbol can be given via Symbol.set_value() (see get_lower_bound()/
    + get_upper_bound()). Returns the empty list for symbol that cannot be
    + given a new value (that cannot be assigned a value that won't be
    + truncated/ignored that is), as well as for non-bool, non-tristate and
    + special symbols. Usage example:
    +
    + if "m" in sym.get_assignable_values():
    + sym.set_value("m")"""
    + if not self._is_assignable_bool_or_tristate():
    + return []
    +
    + return ["n", "m", "y"][values[self.config._eval_expr(self.rev_dep)] :
    + values[self._calc_visibility()] + 1]
    +
    + 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
    +
    + if sym.get_type() == kconfiglib.STRING:
    + ..."""
    + return self.type
    +
    + 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."""
    + return self._calc_visibility()
    +
    + 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 sugar and do not have an explicit class
    + representation."""
    + return self.parent
    +
    + def get_sibling_symbols(self, include_self = False):
    + """Returns a list containing all symbols that are in the same menu or
    + choice statement as the symbol, or that are also at the top level in
    + case the symbol is at the top level.
    +
    + include_self (default: False) -- True if the symbol itself should be
    + included in the result, otherwise
    + False."""
    +
    + return [item for item in self.get_sibling_items(include_self)
    + if isinstance(item, Symbol)]
    +
    + def get_sibling_items(self, include_self = False):
    + """Returns a list containing all items (symbols, menus, choice
    + statements and comments) that are in the same menu or choice statement
    + as the symbol, or that are also at the top level in case the symbol is
    + at the top level. The items appear in the same order as within the
    + configuration.
    +
    + include_self (default: False) -- True if the symbol itself should be
    + included in the result, otherwise
    + False."""
    +
    + if self.parent is None:
    + items = self.config.get_top_level_items()
    + else:
    + items = self.parent.get_items()
    +
    + if include_self:
    + return items
    +
    + return [item for item in items if item is not self]
    +
    + def get_referenced_symbols(self, refs_from_enclosing = False):
    + """Returns the set() of all symbols referenced by this symbol. 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 if's will be
    + included in the result."""
    + return self.all_referenced_syms if refs_from_enclosing else self.referenced_syms
    +
    + 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 self.selected_syms
    +
    + 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_config(self):
    + """Returns the Config instance that represents the configuration this
    + symbol is from."""
    + return self.config
    +
    + 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"
    + """
    + 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
    + """
    + return self.ref_locations
    +
    + def is_modifiable(self):
    + """Returns True or False depending on if the value of symbol could be
    + modified by setting a user value with Symbol.set_value(). This
    + corresponds to symbols that would appear in the 'make menuconfig'
    + interface and not already be pinned to a specific value by being
    + selected. Returns False for special symbols (e.g. n, m and y)."""
    + if self.is_special_:
    + return False
    +
    + allowed = range(self.config._eval_to_int(self.config._eval_expr(self.rev_dep)),
    + self.config._eval_to_int(self._calc_visibility()) + 1)
    +
    + return len(allowed) > 1
    +
    + def is_defined(self):
    + """Returns False if the symbol is referred to in the Kconfig but never
    + actually defined, otherwise True."""
    + return self.is_defined_
    +
    + def is_special(self):
    + """Returns True if the symbol is one of the special symbols n, m or y,
    + or gets its value from the environment. Otherwise, returns False."""
    + return self.is_special_
    +
    + def is_from_environment(self):
    + """Returns True if the symbol gets its value from the environment.
    + Otherwise, returns False."""
    + return self.is_from_env
    +
    + def has_ranges(self):
    + """Returns True if the symbol is of type INT or HEX and has ranges that
    + limits what values it can take on, otherwise False."""
    + return self.ranges != []
    +
    + def is_choice_item(self):
    + """Returns True if the symbol is in a choice statement and is an actual
    + choice item (see Choice.get_actual_items()); otherwise, returns
    + False."""
    + return self.is_choice_item_
    +
    + def is_choice_selection(self):
    + """Returns True if the symbol is contained in a choice statement and is
    + the selected item, otherwise False. Equivalent to 'sym.is_choice_item()
    + and sym.get_parent().get_selection() is sym'."""
    + return self.is_choice_item_ and \
    + self.parent.get_selection() is self
    +
    + def __str__(self):
    + """Returns a string containing various information about the symbol."""
    + return self.config._get_sym_or_choice_str(self)
    +
    + #
    + # Private methods
    + #
    +
    + def __init__(self):
    + """Symbol constructor -- not intended to be called directly by
    + kconfiglib clients."""
    +
    + # Set default values
    + _HasVisibility.__init__(self)
    +
    + self.config = None
    +
    + self.parent = None
    + self.name = None
    + self.type = UNKNOWN
    +
    + self.def_exprs = []
    + self.ranges = []
    + self.rev_dep = "n"
    +
    + # The prompt, default value and select conditions without any
    + # dependencies from menus or if's propagated to them
    +
    + self.orig_prompts = []
    + self.orig_def_exprs = []
    + self.orig_selects = []
    +
    + # Dependencies inherited from containing menus and if's
    + self.deps_from_containing = None
    +
    + self.help = None
    +
    + # The set of symbols referenced by this symbol (see
    + # get_referenced_symbols())
    + self.referenced_syms = set()
    +
    + # The set of symbols selected by this symbol (see
    + # get_selected_symbols())
    + self.selected_syms = set()
    +
    + # Like 'referenced_syms', but includes symbols from
    + # dependencies inherited from enclosing menus and if's
    + self.all_referenced_syms = set()
    +
    + # This is set to True for "actual" choice items. See
    + # Choice._determine_actual_items(). The trailing underscore avoids a
    + # collision with is_choice_item().
    + self.is_choice_item_ = False
    +
    + # This records only dependencies specified with 'depends on'. Needed
    + # when determining actual choice items (hrrrr...). See also
    + # Choice._determine_actual_items().
    + self.menu_dep = None
    +
    + # See Symbol.get_ref/def_locations().
    + self.def_locations = []
    + self.ref_locations = []
    +
    + self.user_val = None
    +
    + # Flags
    +
    + # Should the symbol get an entry in .config?
    + self.write_to_conf = False
    +
    + # Stores the calculated value to avoid unnecessary recalculation
    + self.cached_value = None
    +
    + # Does the symbol have an entry in the Kconfig file? The Trailing
    + # underscore avoids a collision with is_defined().
    + self.is_defined_ = 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_value, which is never
    + # invalidated. The trailing underscore avoids a collision with
    + # is_special().
    + self.is_special_ = False
    +
    + # Does the symbol get its value from the environment?
    + self.is_from_env = False
    +
    + # See Choice._make_conf()
    + self.already_written = False
    +
    + def _invalidate(self):
    + if self.is_special_:
    + return
    +
    + if self.is_choice_item():
    + self.parent._invalidate()
    +
    + _HasVisibility._invalidate(self)
    +
    + self.write_to_conf = False
    + self.cached_value = None
    +
    + def _invalidate_dependent(self):
    + for sym in self._get_dependent():
    + sym._invalidate()
    +
    + def _set_value_no_invalidate(self, v, suppress_load_warnings):
    + """Like set_value(), but does not invalidate any symbols.
    +
    + suppress_load_warnings --
    + some warnings don't make sense when loading a .config that do make
    + sense when manually invoking set_value(). This flag is set to True to
    + suppress such warnings."""
    +
    + if self.is_special_:
    + if self.is_from_env:
    + self.config._warn('attempt to assign the value "{0}" to the '
    + 'symbol {1}, which gets its value from the '
    + 'environment. Assignment ignored.'
    + .format(v, self.name))
    + else:
    + self.config._warn('attempt to assign the value "{0}" to the '
    + 'special symbol {1}. Assignment ignored.'
    + .format(v, self.name))
    +
    + return
    +
    +
    + if not self.is_defined_:
    + filename, linenr = self.ref_locations[0]
    +
    + self.config._undef_assign('attempt to assign the value "{0}" to {1}, '
    + "which is referenced at {2}:{3} but never "
    + "defined. Assignment ignored."
    + .format(v, self.name, filename, linenr))
    + return
    +
    + # Check if the value is valid for our type
    +
    + valid = ( 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_dec(v) ) or \
    + ( self.type == HEX and _is_hex(v) )
    +
    + if not valid:
    + self.config._warn('the value "{0}" is invalid for {1}, which has type {2}. '
    + "Assignment ignored."
    + .format(v, self.name, typename[self.type]))
    + return
    +
    + if self.prompts == [] and not suppress_load_warnings:
    + self.config._warn('assigning "{0}" to the symbol {1} which lacks '
    + 'prompts and thus has visibility "n". The assignment '
    + 'will have no effect.'
    + .format(v, self.name))
    +
    + self.user_val = v
    +
    + if self.is_choice_item() 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"
    +
    + def _reset_no_recursive_invalidate(self):
    + self._invalidate()
    + self.user_val = None
    +
    + if self.is_choice_item():
    + self.parent._reset()
    +
    + def _should_write(self):
    + # This check shouldn't be necessary as write_to_conf is never modified
    + # in calc_value() for special symbols, but just to be on the safe side:
    + if self.is_special_:
    + return False
    +
    + # Symbols defined in multiple locations only get one entry in the
    + # .config.
    + if self.already_written:
    + return False
    +
    + # write_to_conf is determined in calc_value(), so we need to call that
    + # first
    + self.calc_value()
    +
    + return self.write_to_conf
    +
    + def _make_conf(self):
    + if not self._should_write():
    + return []
    +
    + self.already_written = True
    +
    + if self.type in (BOOL, TRISTATE):
    + if self.calc_value() in ("m", "y"):
    + return ["CONFIG_{0}={1}".format(self.name, self.calc_value())]
    + return ["# CONFIG_{0} is not set".format(self.name)]
    +
    + elif self.type == STRING:
    + return ['CONFIG_{0}="{1}"'.format(self.name, self.calc_value())]
    +
    + elif self.type in (INT, HEX):
    + return ["CONFIG_{0}={1}".format(self.name, self.calc_value())]
    +
    + else:
    + _internal_error('Internal error while creating .config: unknown type "{0}".'
    + .format(self.type))
    +
    + def _get_dependent(self):
    + """Returns the list of symbols that should be invalidated if the value
    + of the symbol changes."""
    + res = set()
    +
    + def rec(sym, ignore_choice = False):
    + for s in self.config.dep[sym]:
    + if s not in res:
    + res.add(s)
    + rec(s)
    +
    + # Handle choices specially to avoid lots of hopping around between
    + # choice items (which all depend on each other) while calculating
    + # dependencies
    + if sym.is_choice_item() and not ignore_choice:
    + choice = sym.get_parent()
    +
    + for s in choice.get_actual_items():
    + if s not in res and s is not self:
    + res.add(s)
    + rec(s, True)
    +
    + rec(self)
    + return res
    +
    + def _has_auto_menu_dep_on(self, on):
    + """See Choice._determine_actual_items()."""
    + if not isinstance(self.parent, Choice):
    + _internal_error("Attempt to determine auto menu dependency for symbol ouside of choice.")
    +
    + if 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
    +
    + def _is_assignable_bool_or_tristate(self):
    + """Returns True if the symbol is a bool or tristate whose value can be
    + changed by the user."""
    + return self.type in (BOOL, TRISTATE) and \
    + not self.is_special_ and \
    + (self.config._eval_to_int(self._calc_visibility()) -
    + self.config._eval_to_int(self.config._eval_expr(self.rev_dep))) >= 1
    +
    +class Menu(Item):
    +
    + """Represents a menu statement."""
    +
    + #
    + # Public interface
    + #
    +
    + def get_depends_on_visibility(self):
    + """Returns the visibility the menu gets from 'depends on' conditions.
    + This is propagated to subitems."""
    + return self.config._eval_expr(self.dep_expr)
    +
    + def get_visible_if_visibility(self):
    + """Returns the visibility the menu gets from its 'visible if'
    + condition. "y" is the menu has no 'visible if' condition."""
    + return self.config._eval_expr(self.visible_if_expr)
    +
    + 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.get_items()
    +
    + res = []
    + for item in self.block.get_items():
    + 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_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_referenced_symbols(self, refs_from_enclosing = False):
    + """See Symbol.get_referenced_symbols()."""
    + return self.all_referenced_syms if refs_from_enclosing else self.referenced_syms
    +
    + 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 __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 _sep_lines("Menu",
    + "Title : " + self.title,
    + "'depends on' dependencies : " + depends_on_str,
    + "'visible if' dependencies : " + visible_if_str,
    + "Additional dependencies from enclosing menus and if's:",
    + additional_deps_str,
    + "Location: {0}:{1}".format(self.filename, self.linenr))
    +
    + #
    + # Private methods
    + #
    +
    + def __init__(self):
    + """Menu constructor -- not intended to be called directly by
    + kconfiglib clients."""
    +
    + self.config = None
    +
    + self.parent = None
    + self.title = None
    + self.block = None
    + self.dep_expr = None
    +
    + # Dependency expression without dependencies from enclosing menus and
    + # if's propagated
    + self.orig_deps = None
    +
    + # Dependencies inherited from containing menus and if's
    + self.deps_from_containing = None
    +
    + # The 'visible if' expression
    + self.visible_if_expr = None
    +
    + # The set of symbols referenced by this menu (see
    + # get_referenced_symbols())
    + self.referenced_syms = set()
    +
    + # Like 'referenced_syms', but includes symbols from
    + # dependencies inherited from enclosing menus and if's
    + self.all_referenced_syms = None
    +
    + self.filename = None
    + self.linenr = None
    +
    + def _make_conf(self):
    + item_conf = self.block._make_conf()
    +
    + if self.config._eval_expr(self.dep_expr) != "n" and \
    + self.config._eval_expr(self.visible_if_expr) != "n":
    + return ["\n#\n# {0}\n#".format(self.title)] + item_conf
    + else:
    + return item_conf
    +
    +class Choice(Item, _HasVisibility):
    +
    + """Represents a choice statement. A choice can be in one of three modes:
    + "n", "m" and "y". "n" mode is for non-visible choices and optional choices
    + with no symbol selected; "m" means any number of symbols can be set to "m"
    + while the rest will be "n" (only tristate choices can be in this mode); and
    + "y" means one symbol will be "y" while the rest will be "n" (the most
    + common case). The visibility is an upper bound on the mode, and the mode
    + changes automatically as values are assigned to symbols within the
    + choice."""
    +
    + #
    + # Public interface
    + #
    +
    + 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
    + return self.cached_selection
    +
    + if self.calc_mode() != "y":
    + return self._cache_ret(None)
    +
    + # User choice available?
    + if self.user_val is not None and \
    + self.user_val._calc_visibility() == "y":
    + return self._cache_ret(self.user_val)
    +
    + if self.optional:
    + return self._cache_ret(None)
    +
    + return self._cache_ret(self.get_selection_from_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."""
    +
    + if self.actual_items == []:
    + return None
    +
    + for (symbol, cond_expr) in self.def_exprs:
    + if self.config._eval_expr(cond_expr) != "n":
    + chosen_symbol = symbol
    + break
    + else:
    + chosen_symbol = self.actual_items[0]
    +
    + # Is the chosen symbol visible?
    + if chosen_symbol._calc_visibility() != "n":
    + return chosen_symbol
    + else:
    + # Otherwise, pick the first visible symbol
    + for sym in self.actual_items:
    + if sym._calc_visibility() != "n":
    + return sym
    +
    + 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_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 2.6.38-rc3."""
    + return self.name
    +
    + def get_type(self):
    + """Returns the type of the choice. See Symbol.get_type()."""
    + return self.type
    +
    + 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 2.6.38-rc3, in drivers/usb/gadget/Kconfig)."""
    + return self.block.get_items()
    +
    + def get_actual_items(self):
    + """A quirk (perhaps better described as a bug -- at least for symbols)
    + 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.
    +
    + This function gets a list of the "proper" elements of the choice,
    + excluding such items."""
    + return self.actual_items
    +
    + 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_referenced_symbols(self, refs_from_enclosing = False):
    + """See Symbol.get_referenced_symbols()."""
    + return self.all_referenced_syms if refs_from_enclosing else self.referenced_syms
    +
    + 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 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_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 self._calc_visibility()
    +
    + def calc_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, self._calc_visibility())
    +
    + # Promote "m" to "y" for boolean choices
    + if mode == "m" and self.type == BOOL:
    + mode = "y"
    +
    + return mode
    +
    + def is_optional(self):
    + """Returns True if the symbol has the optional flag set (and so will default
    + to "n" mode). Otherwise, returns False."""
    + return self.optional
    +
    + def __str__(self):
    + """Returns a string containing various information about the choice
    + statement."""
    + return self.config._get_sym_or_choice_str(self)
    +
    + #
    + # Private methods
    + #
    +
    + def __init__(self):
    + """Choice constructor -- not intended to be called directly by
    + kconfiglib clients."""
    +
    + _HasVisibility.__init__(self)
    +
    + self.config = None
    +
    + self.parent = None
    + self.name = None # Yes, choices can be named
    + self.type = UNKNOWN
    + self.def_exprs = []
    + self.help = None
    + self.optional = False
    + self.block = None
    +
    + # The prompts and default values without any dependencies from
    + # enclosing menus or if's propagated
    +
    + self.orig_prompts = []
    + self.orig_def_exprs = []
    +
    + # Dependencies inherited from containing menus and if's
    + self.deps_from_containing = None
    +
    + # We need to filter out symbols that appear within the choice block but
    + # are not considered choice items (see
    + # Choice._determine_actual_items()) This list holds the "actual" choice
    + # items.
    + self.actual_items = []
    +
    + # The set of symbols referenced by this choice (see
    + # get_referenced_symbols())
    + self.referenced_syms = set()
    +
    + # Like 'referenced_syms', but includes symbols from
    + # dependencies inherited from enclosing menus and if's
    + self.all_referenced_syms = set()
    +
    + # See Choice.get_def_locations()
    + self.def_locations = []
    +
    + self.user_val = None
    + self.user_mode = None
    +
    + self.cached_selection = None
    +
    + def _determine_actual_items(self):
    + """If a symbol's visibility depends on the preceding symbol within a
    + choice, it is no longer viewed as a choice item (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 as 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_item_ flag on them (retrieved via is_choice_item()).
    +
    + 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 ;)."""
    +
    + items = self.block.get_items()
    +
    + # 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 items:
    + if not isinstance(item, Symbol):
    + stack = []
    + continue
    +
    + 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_item_.
    + stack.append(item)
    + break
    + else:
    + stack.pop()
    + else:
    + item.is_choice_item_ = True
    + self.actual_items.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
    +
    + return selection
    +
    + def _get_user_mode(self):
    + return self.user_mode
    +
    + def _invalidate(self):
    + _HasVisibility._invalidate(self)
    + self.cached_selection = None
    +
    + def _reset(self):
    + self._invalidate()
    + self.user_val = None
    + self.user_mode = None
    +
    + def _make_conf(self):
    + return self.block._make_conf()
    +
    +class Comment(Item):
    +
    + """Represents a comment statement."""
    +
    + #
    + # Public interface
    + #
    +
    + def get_text(self):
    + """Returns the text of the comment."""
    + return self.text
    +
    + 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
    +
    + def get_referenced_symbols(self, refs_from_enclosing = False):
    + """See Symbol.get_referenced_symbols()."""
    + return self.all_referenced_syms if refs_from_enclosing else self.referenced_syms
    +
    + 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)
    +
    + 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 _sep_lines("Comment",
    + "Text: " + str(self.text),
    + "Dependencies: " + dep_str,
    + "Additional dependencies from enclosing menus and if's:",
    + additional_deps_str,
    + "Location: {0}:{1}".format(self.filename, self.linenr))
    +
    + #
    + # Private methods
    + #
    +
    + def __init__(self):
    + """Comment constructor -- not intended to be called directly by
    + kconfiglib clients."""
    +
    + self.config = None
    +
    + self.parent = None
    + self.text = None
    + self.dep_expr = None
    +
    + # Dependency expression without dependencies from enclosing menus and
    + # if's propagated
    + self.orig_deps = None
    +
    + # Dependencies inherited from containing menus and if's
    + self.deps_from_containing = None
    +
    + # The set of symbols referenced by this comment (see
    + # get_referenced_symbols())
    + self.referenced_syms = set()
    +
    + # Like 'referenced_syms', but includes symbols from
    + # dependencies inherited from enclosing menus and if's
    + self.all_referenced_syms = None
    +
    + self.filename = None
    + self.linenr = None
    +
    + def _make_conf(self):
    + if self.config._eval_expr(self.dep_expr) != "n":
    + return ["\n#\n# {0}\n#".format(self.text)]
    + else:
    + return []
    +
    +class _Feed:
    +
    + """Class for working with sequences in a stream-like fashion; handy for tokens."""
    +
    + def __init__(self, items):
    + self.items = items
    + self.length = len(self.items)
    + self.i = 0
    +
    + def get_next(self):
    + if self.i >= self.length:
    + return None
    +
    + item = self.items[self.i]
    + self.i += 1
    + return item
    +
    + def peek_next(self):
    + return None if self.i >= self.length else self.items[self.i]
    +
    + def go_to_start(self):
    + self.i = 0
    +
    + def __getitem__(self, index):
    + return self.items[index]
    +
    + def __len__(self):
    + return len(self.items)
    +
    + def is_empty(self):
    + return self.items == []
    +
    + def is_at_end(self):
    + return self.i >= self.length
    +
    + 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."""
    + if self.i >= self.length:
    + return None
    +
    + if self.items[self.i] == token:
    + self.i += 1
    + return True
    +
    + return False
    +
    + def remove_while(self, pred):
    + while self.i < self.length and pred(self.items[self.i]):
    + self.i += 1
    +
    + def go_back(self):
    + if self.i <= 0:
    + _internal_error("Attempt to move back in Feed while already at the beginning.")
    + self.i -= 1
    +
    +class _FileFeed(_Feed):
    +
    + """Feed subclass that keeps track of the current filename and line
    + number."""
    +
    + def __init__(self, lines, filename):
    + self.filename = _clean_up_path(filename)
    + _Feed.__init__(self, lines)
    +
    + def get_filename(self):
    + return self.filename
    +
    + def get_linenr(self):
    + return self.i
    +
    +#
    +# Misc. public global utility functions
    +#
    +
    +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. Otherwise, returns
    + False."""
    + return values[v1] < values[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. Otherwise,
    + returns False."""
    + return values[v1] <= values[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. Otherwise, returns
    + False."""
    + return values[v1] > values[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. Otherwise,
    + returns False."""
    + return values[v1] >= values[v2]
    +
    +#
    +# Helper functions, mostly related to text processing
    +#
    +
    +def _strip_quotes(s, line, filename, linenr):
    + """Removes any quotes surrounding 's' if it has them; otherwise returns 's'
    + unmodified."""
    + s = s.strip()
    + if s[0] == '"' or s[0] == "'":
    + if len(s) < 2 or s[-1] != s[0]:
    + _parse_error(line,
    + "malformed string literal",
    + filename,
    + linenr)
    + return s[1:-1]
    + else:
    + return s
    +
    +def _indentation(line):
    + """Returns the indentation of the line, treating tab stops as being spaced
    + 8 characters apart."""
    + if line.isspace():
    + _internal_error("Attempt to take indentation of blank line.")
    + indent = 0
    + for c in line:
    + if c == " ":
    + indent += 1
    + elif c == "\t":
    + # Go to the next tab stop
    + indent = (indent + 8) & ~7
    + else:
    + return indent
    +
    +def _deindent(line, indent):
    + """Deindent 'line' by 'indent' spaces."""
    + line = line.expandtabs()
    + if len(line) <= indent:
    + return line
    + return line[indent:]
    +
    +def _is_hex(s):
    + return _is_base_n(s, 16)
    +
    +def _is_dec(s):
    + return _is_base_n(s, 10)
    +
    +def _is_base_n(s, n):
    + try:
    + int(s, n)
    + return True
    + except ValueError:
    + return False
    +
    +def _sep_lines(*args):
    + """Returns a string comprised of all arguments, with newlines inserted
    + between them."""
    + return "\n".join(args)
    +
    +def _comment(s):
    + """Returns a new string with "# " inserted before each line in 's'."""
    + return "\n".join(["# " + line for line in s.splitlines()])
    +
    +def _get_lines(filename):
    + """Returns a list of lines from 'filename', joining any line ending in \\
    + with the following line."""
    + with open(filename, "r") as f:
    + lines = []
    + accum = ""
    + while True:
    + line = f.readline()
    +
    + if line == "":
    + return lines
    +
    + if line.endswith("\\\n"):
    + accum += line[:-2]
    + else:
    + accum += line
    + lines.append(accum)
    + accum = ""
    +
    +def _strip_trailing_slash(path):
    + """Removes any trailing slash from 'path'."""
    + return path[:-1] if path.endswith("/") else path
    +
    +def _clean_up_path(path):
    + """Strips any initial "./" and trailing slash from 'path'."""
    + if path.startswith("./"):
    + path = path[2:]
    + return _strip_trailing_slash(path)
    +
    +#
    +# Error handling
    +#
    +
    +class Kconfig_Syntax_Error(Exception):
    + """Exception raised for syntax errors."""
    + pass
    +
    +class Internal_Error(Exception):
    + """Exception raised for internal errors."""
    + pass
    +
    +def _tokenization_error(s, index, filename, linenr):
    + if filename is not None:
    + assert linenr is not None
    + sys.stderr.write("{0}:{1}:\n".format(filename, linenr))
    +
    + if s.endswith("\n"):
    + s = s[:-1]
    +
    + # Calculate the visual offset corresponding to index 'index' in 's'
    + # assuming tabstops are spaced 8 characters apart
    + vis_index = 0
    + for c in s[:index]:
    + if c == "\t":
    + vis_index = (vis_index + 8) & ~7
    + else:
    + vis_index += 1
    +
    + # Don't output actual tabs to be independent of how the terminal renders
    + # them
    + s = s.expandtabs()
    +
    + raise Kconfig_Syntax_Error, (
    + _sep_lines("Error during tokenization at location indicated by caret.\n",
    + s,
    + " " * vis_index + "^\n"))
    +
    +def _parse_error(s, msg, filename, linenr):
    + error_str = ""
    +
    + if filename is not None:
    + assert linenr is not None
    + error_str += "{0}:{1}: ".format(filename, linenr)
    +
    + if s.endswith("\n"):
    + s = s[:-1]
    +
    + error_str += 'Error while parsing "{0}"'.format(s)
    +
    + if msg is None:
    + error_str += "."
    + else:
    + error_str += ": " + msg
    +
    + raise Kconfig_Syntax_Error, error_str
    +
    +def _internal_error(msg):
    + msg += "\nSorry! You may want to send an email to kconfiglib@gmail.com " \
    + "to tell me about this. Include the message above and the stack " \
    + "trace and describe what you were doing."
    +
    + raise Internal_Error, msg
    +
    +if use_psyco:
    + import psyco
    +
    + Config._tokenize = psyco.proxy(Config._tokenize)
    + Config._eval_expr = psyco.proxy(Config._eval_expr)
    +
    + _indentation = psyco.proxy(_indentation)
    + _get_lines = psyco.proxy(_get_lines)
    diff --git a/scripts/kconfig/kconfigtest.py b/scripts/kconfig/kconfigtest.py
    new file mode 100644
    index 0000000..9d27dca
    --- /dev/null
    +++ b/scripts/kconfig/kconfigtest.py
    @@ -0,0 +1,396 @@
    +# This is a test suite for kconfiglib, primarily testing compatibility with the
    +# C kconfig implementation by comparing outputs. It should be run from the
    +# top-level kernel directory with
    +#
    +# $ PYTHONPATH=scripts/kconfig python scripts/kconfig/kconfigtest.py
    +#
    +# Note that running these could take a long time: running all tests on a Core
    +# i7@2.67 GHz takes ~2 hours. The tests have been arranged in order of time
    +# needed.
    +#
    +# All tests should pass. Report regressions to kconfiglib@gmail.com
    +
    +import kconfiglib
    +import os
    +import re
    +import subprocess
    +import sys
    +
    +# Assume that the value of KERNELVERSION does not affect the configuration
    +# (true as of Linux 2.6.38-rc3). Here we could fetch the correct version
    +# instead.
    +os.environ["KERNELVERSION"] = "2"
    +
    +# Number of arch/defconfig pairs tested so far
    +nconfigs = 0
    +
    +def run_tests():
    + # The set of tests that want to run for all architectures in the kernel
    + # tree -- currently, all tests. The boolean flag indicates whether .config
    + # (generated by the C implementation) should be compared to ._config
    + # (generated by us) after each invocation.
    + all_arch_tests = [(test_all_no, True),
    + (test_config_absent, True),
    + (test_all_yes, True),
    + (test_call_all, False),
    + # Needs to report success/failure for each arch/defconfig
    + # combo, hence False.
    + (test_defconfig, False)]
    +
    + print "Loading Config instances for all architectures..."
    + arch_configs = get_arch_configs()
    +
    + for (test_fn, compare_configs) in all_arch_tests:
    + print "Resetting all architecture Config instances prior to next test..."
    + for arch in arch_configs:
    + arch.reset()
    +
    + # The test description is taken from the docstring of the corresponding
    + # function
    + print test_fn.__doc__
    +
    + for conf in arch_configs:
    + rm_configs()
    +
    + # This should be set correctly for any 'make *config' commands the
    + # test might run
    + os.environ["ARCH"] = conf.get_arch()
    +
    + test_fn(conf)
    +
    + if compare_configs:
    + sys.stdout.write(" {0:<14}".format(conf.get_arch()))
    +
    + if equal_confs():
    + print "OK"
    + else:
    + print "FAIL"
    + fail()
    +
    + print ""
    +
    + if all_ok():
    + print "All OK"
    + print nconfigs, "arch/defconfig pairs tested"
    + else:
    + print "Some tests failed"
    +
    +def get_arch_configs():
    + """Returns a list with Config instances corresponding to all arch Kconfigs."""
    +
    + def add_arch(ARCH, res):
    + os.environ["SRCARCH"] = archdir
    + os.environ["ARCH"] = ARCH
    + res.append(kconfiglib.Config())
    +
    + res = []
    +
    + # Nothing looks at this as of Linux 2.6.38-rc3
    + os.environ["KERNELVERSION"] = "2"
    +
    + for archdir in os.listdir("arch"):
    + if archdir == "h8300":
    + # Broken Kconfig as of Linux 2.6.38-rc3
    + continue
    +
    + if os.path.exists(os.path.join("arch", archdir, "Kconfig")):
    + if archdir == "x86":
    + add_arch("i386", res)
    + add_arch("x86_64", res)
    + elif archdir == "sparc":
    + add_arch("sparc32", res)
    + add_arch("sparc64", res)
    + elif archdir == "sh":
    + add_arch("sh64", res)
    + else:
    + # For most architectures, ARCH = SRCARCH
    + add_arch(archdir, res)
    +
    + # Don't want subsequent 'make *config' commands in tests to see this
    + del os.environ["ARCH"]
    + del os.environ["SRCARCH"]
    +
    + return res
    +
    +def test_all_no(conf):
    + """Test if our allnoconfig implementation generates the same .config as 'make allnoconfig', for all architectures"""
    +
    + while True:
    + done = True
    +
    + for sym in conf:
    + # Choices take care of themselves for allnoconf, so we only need to
    + # worry about non-choice symbols
    + if not sym.is_choice_item():
    + lower_bound = sym.get_lower_bound()
    +
    + # If we can assign a lower value to the symbol (where "n", "m" and
    + # "y" are ordered from lowest to highest), then do so.
    + # lower_bound() returns None for symbols whose values cannot
    + # (currently) be changed, as well as for non-bool, non-tristate
    + # symbols.
    + if lower_bound is not None and \
    + kconfiglib.tri_less(lower_bound, sym.calc_value()):
    +
    + sym.set_value(lower_bound)
    +
    + # We just changed the value of some symbol. As this may effect
    + # other symbols, we need to keep looping.
    + done = False
    +
    + if done:
    + break
    +
    + conf.write_config("._config")
    +
    + shell("make allnoconfig")
    +
    +def test_all_yes(conf):
    + """Test if our allyesconfig implementation generates the same .config as 'make allyesconfig', for all architectures"""
    +
    + # Get a list of all symbols that are not choice items
    + non_choice_syms = [sym for sym in conf.get_symbols() if
    + not sym.is_choice_item()]
    +
    + while True:
    + done = True
    +
    + # Handle symbols outside of choices
    +
    + for sym in non_choice_syms:
    + upper_bound = sym.get_upper_bound()
    +
    + # See corresponding comment for allnoconf implementation
    + if upper_bound is not None and \
    + kconfiglib.tri_less(sym.calc_value(), upper_bound):
    + sym.set_value(upper_bound)
    + done = False
    +
    + # Handle symbols within choices
    +
    + for choice in conf.get_choices():
    +
    + # Handle choices whose visibility allow them to be in "y" mode
    +
    + if choice.get_visibility() == "y":
    + selection = choice.get_selection_from_defaults()
    + if selection is not None and \
    + selection is not choice.get_user_selection():
    + selection.set_value("y")
    + done = False
    +
    + # Handle choices whose visibility only allow them to be in "m" mode
    +
    + elif choice.get_visibility() == "m":
    + for sym in choice.get_items():
    + if sym.calc_value() != "m" and \
    + sym.get_upper_bound() != "n":
    + sym.set_value("m")
    + done = False
    +
    +
    + if done:
    + break
    +
    + conf.write_config("._config")
    +
    + shell("make allyesconfig")
    +
    +def test_call_all(conf):
    + """Call all public methods on all symbols, menus, choices and comments (nearly all public methods: some are hard to test like this, but are exercised by other tests) for all architectures to make sure we never crash or hang"""
    + print " For {0}...".format(conf.get_arch())
    +
    + conf.get_arch()
    + conf.get_defconfig_filename()
    + conf.get_top_level_items()
    + conf.eval("y && ARCH")
    +
    + # Syntax error
    + caught_exception = False
    + try:
    + conf.eval("y & y")
    + except kconfiglib.Kconfig_Syntax_Error:
    + caught_exception = True
    +
    + if not caught_exception:
    + print "Fail: no exception generated for expression with syntax error"
    + fail()
    +
    + conf.get_config_header()
    + conf.get_base_dir()
    + conf.reset()
    + conf.get_symbols(False)
    + conf.get_mainmenu_text()
    +
    + for s in conf.get_symbols():
    + s.reset()
    + s.calc_value()
    + s.calc_default_value()
    + s.get_user_value()
    + s.get_name()
    + s.get_upper_bound()
    + s.get_lower_bound()
    + s.get_assignable_values()
    + s.get_type()
    + s.get_visibility()
    + s.get_parent()
    + s.get_sibling_symbols()
    + s.get_sibling_items()
    + s.get_referenced_symbols()
    + s.get_referenced_symbols(True)
    + s.get_selected_symbols()
    + s.get_help()
    + s.get_config()
    + s.get_def_locations()
    + s.get_ref_locations()
    + s.is_modifiable()
    + s.is_defined()
    + s.is_special()
    + s.is_from_environment()
    + s.has_ranges()
    + s.is_choice_item()
    + s.is_choice_selection()
    + s.__str__()
    +
    + for c in conf.get_choices():
    + if c.get_name() is not None:
    + print "LOOOOOOOOL", c.get_name()
    + c.get_selection()
    + c.get_selection_from_defaults()
    + c.get_user_selection()
    + c.get_type()
    + c.get_name()
    + c.get_items()
    + c.get_actual_items()
    + c.get_parent()
    + c.get_referenced_symbols()
    + c.get_referenced_symbols(True)
    + c.get_def_locations()
    + c.get_visibility()
    + c.calc_mode()
    + c.is_optional()
    + c.__str__()
    +
    + for m in conf.get_menus():
    + m.get_items()
    + m.get_symbols(False)
    + m.get_symbols(True)
    + m.get_depends_on_visibility()
    + m.get_visible_if_visibility()
    + m.get_title()
    + m.get_parent()
    + m.get_referenced_symbols()
    + m.get_referenced_symbols(True)
    + m.get_location()
    + m.__str__()
    +
    + for c in conf.get_comments():
    + c.get_text()
    + c.get_parent()
    + c.get_referenced_symbols()
    + c.get_referenced_symbols(True)
    + c.get_location()
    + c.__str__()
    +
    +def test_config_absent(conf):
    + """Test if kconfiglib generates the same configuration as 'conf' without a .config, for each architecture"""
    + conf.write_config("._config")
    +
    + # Use an empty .config
    + shell("> .config")
    + shell("make kconfiglibtestconfig")
    +
    +def test_defconfig(conf):
    + """Test if kconfiglib generates the same .config as conf for each architecture/defconfig pair (this takes two hours on a Core i7@2.67 GHz system)"""
    + # Collect defconfigs. This could be done once instead, but it's a speedy
    + # operation comparatively.
    +
    + global nconfigs
    +
    + defconfigs = []
    +
    + for arch in os.listdir("arch"):
    + arch_dir = os.path.join("arch", arch)
    +
    + # Some arches have a "defconfig" in their
    + # arch directory.
    + defconfig = os.path.join(arch_dir, "defconfig")
    + if os.path.exists(defconfig):
    + defconfigs.append(defconfig)
    +
    + defconfigs_dir = os.path.join(arch_dir, "configs")
    + if os.path.isdir(defconfigs_dir):
    + for c in os.listdir(defconfigs_dir):
    + defconfig = os.path.join(defconfigs_dir, c)
    + if os.path.isfile(defconfig):
    + defconfigs.append(defconfig)
    +
    + # Test architecture for each defconfig
    +
    + for defconfig in defconfigs:
    + rm_configs()
    +
    + nconfigs += 1
    +
    + conf.load_config(defconfig)
    + conf.write_config("._config")
    + shell("cp {0} .config".format(defconfig))
    + shell("make kconfiglibtestconfig")
    +
    + sys.stdout.write(" {0:<14}with {1:<60} ".format(conf.get_arch(), defconfig))
    +
    + if equal_confs():
    + print "OK"
    + else:
    + print "FAIL"
    + fail()
    +
    +#
    +# Helper functions
    +#
    +
    +def shell(cmd):
    + subprocess.Popen(cmd,
    + shell = True,
    + stdout = subprocess.PIPE,
    + stderr = subprocess.PIPE).wait()
    +
    +def rm_configs():
    + """Delete any old ".config" (generated by the C implementation) and
    + "._config" (generated by us), if present."""
    + def rm_if_exists(f):
    + if os.path.exists(f):
    + os.remove(f)
    +
    + rm_if_exists(".config")
    + rm_if_exists("._config")
    +
    +def equal_confs():
    + with open(".config") as menu_conf:
    + l1 = menu_conf.readlines()
    +
    + with open("._config") as my_conf:
    + l2 = my_conf.readlines()
    +
    + # Skip the header generated by 'conf'
    + unset_re = r"# CONFIG_(\w+) is not set"
    + i = 0
    + for line in l1:
    + if not line.startswith("#") or \
    + re.match(unset_re, line):
    + break
    + i += 1
    +
    + return (l1[i:] == l2)
    +
    +_all_ok = True
    +
    +def fail():
    + global _all_ok
    + _all_ok = False
    +
    +def all_ok():
    + return _all_ok
    +
    +if __name__ == "__main__":
    + run_tests()
    --
    1.7.0.4


    \
     
     \ /
      Last update: 2011-02-02 00:31    [W:0.343 / U:0.128 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site