From 989e9f77cfe8caabc7ac241572e9b52682901135 Mon Sep 17 00:00:00 2001
From: Ulf Magnusson <ulfalizer@gmail.com>
Date: Mon, 30 Oct 2017 00:50:09 +0100
Subject: Consistently use 0/1/2 for tristate values

Easier to work with, allowing e.g. direct comparisons with < and >. Make
set_value() take 0, 1, 2 for bool and tristate symbols, and fix other
APIs to match.

Also:

  - Add introductions to various concepts in the module docstring.
    Document some more attributes. Still TODOs.

  - Rename the Config class to Kconfig.

  - Escape " and \ in the name of constant symbols when printing them.
    Also make the (un)escaping 100% consistent with how the C tools do
    it (\ before non-magic character should be unescaped too).

  - Clean up the escaping/unescaping code and provide two public
    escape()/unescape() functions.

  - Export the original MODULES-independent type in orig_type. It's
    needed for printing symbols in the reparsable __str__() Kconfig
    format with just public APIs.

  - Lots of other minor reorganizing and nits all over.
---
 examples/allnoconfig.py         |    8 +-
 examples/allnoconfig_simpler.py |    8 +-
 examples/allyesconfig.py        |   22 +-
 examples/defconfig.py           |    2 +-
 examples/defconfig_oldconfig.py |   10 +-
 examples/eval_expr.py           |    4 +-
 examples/help_grep.py           |    4 +-
 examples/print_sym_info.py      |   63 +-
 examples/print_tree.py          |    4 +-
 kconfiglib.py                   | 1566 +++++++++++++++++++++++----------------
 testsuite.py                    |  350 +++++----
 11 files changed, 1188 insertions(+), 853 deletions(-)

diff --git a/examples/allnoconfig.py b/examples/allnoconfig.py
index 2348da4..be36b47 100644
--- a/examples/allnoconfig.py
+++ b/examples/allnoconfig.py
@@ -8,7 +8,7 @@
 #
 #   $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/allnoconfig.py
 
-from kconfiglib import Config, Symbol, STR_TO_TRI
+from kconfiglib import Kconfig, Symbol, STR_TO_TRI
 import sys
 
 def do_allnoconfig(node):
@@ -27,7 +27,7 @@ def do_allnoconfig(node):
             if (sym.choice is None and
                 not sym.is_allnoconfig_y and
                 sym.assignable and
-                STR_TO_TRI[sym.assignable[0]] < sym.tri_value):
+                sym.assignable[0] < sym.tri_value):
 
                 # Yup, lower it
                 sym.set_value(sym.assignable[0])
@@ -39,12 +39,12 @@ def do_allnoconfig(node):
 
         node = node.next
 
-conf = Config(sys.argv[1])
+conf = Kconfig(sys.argv[1])
 
 # Do an initial pass to set 'option allnoconfig_y' symbols to 'y'
 for sym in conf.defined_syms:
     if sym.is_allnoconfig_y:
-        sym.set_value("y")
+        sym.set_value(2)
 
 while 1:
     # Changing later symbols in the configuration can sometimes allow earlier
diff --git a/examples/allnoconfig_simpler.py b/examples/allnoconfig_simpler.py
index e732669..59a1bd4 100644
--- a/examples/allnoconfig_simpler.py
+++ b/examples/allnoconfig_simpler.py
@@ -12,17 +12,17 @@
 # Kconfiglib immediately invalidates (flags for recalculation) all (possibly)
 # dependent symbols when a value is assigned to a symbol, which slows this down
 # a bit (due to tons of redundant invalidation), but makes any assignment
-# pattern safe ("just works"). Config.load_config() instead invalidates all
+# pattern safe ("just works"). Kconfig.load_config() instead invalidates all
 # symbols up front, making it much faster. If you really need to eke out
 # performance, look at how load_config() does things (which involves internal
 # APIs that don't invalidate symbols). This has been fast enough for all cases
 # I've seen so far though (around 3 seconds for this particular script on my
 # Core i7 2600K, including the initial Kconfig parsing).
 
-from kconfiglib import Config, BOOL, TRISTATE
+from kconfiglib import Kconfig, BOOL, TRISTATE
 import sys
 
-conf = Config(sys.argv[1])
+conf = Kconfig(sys.argv[1])
 
 # Avoid warnings printed by Kconfiglib when assigning a value to a symbol that
 # has no prompt. Such assignments never have an effect.
@@ -30,6 +30,6 @@ conf.disable_warnings()
 
 for sym in conf.defined_syms:
     if sym.type in (BOOL, TRISTATE):
-        sym.set_value("y" if sym.is_allnoconfig_y else "n")
+        sym.set_value(2 if sym.is_allnoconfig_y else 0)
 
 conf.write_config(".config")
diff --git a/examples/allyesconfig.py b/examples/allyesconfig.py
index f91b6d7..6e2e065 100644
--- a/examples/allyesconfig.py
+++ b/examples/allyesconfig.py
@@ -8,20 +8,20 @@
 # allyesconfig is a bit more involved than allnoconfig as we need to handle
 # choices in two different modes:
 #
-#   y: One symbol is "y", the rest are "n"
-#   m: Any number of symbols are "m", the rest are "n"
+#   y: One symbol is y, the rest are n
+#   m: Any number of symbols are m, the rest are n
 #
-# Only tristate choices can be in "m" mode. No "m" mode choices seem to appear
-# for allyesconfig on the kernel Kconfigs as of 4.14, but we still handle it.
+# Only tristate choices can be in m mode. No m mode choices seem to appear for
+# allyesconfig on the kernel Kconfigs as of 4.14, but we still handle it.
 #
 # Usage:
 #
 #   $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/allyesconfig.py
 
-from kconfiglib import Config, Choice, STR_TO_TRI
+from kconfiglib import Kconfig, Choice, STR_TO_TRI
 import sys
 
-conf = Config(sys.argv[1])
+conf = Kconfig(sys.argv[1])
 
 # Collect all the choices in the configuration. Demonstrates how the menu node
 # tree can be walked iteratively by using the parent pointers.
@@ -70,14 +70,14 @@ while 1:
     for sym in non_choice_syms:
         # See allnoconfig example. [-1] gives the last (highest) assignable
         # value.
-        if sym.assignable and sym.tri_value < STR_TO_TRI[sym.assignable[-1]]:
+        if sym.assignable and sym.tri_value < sym.assignable[-1]:
             sym.set_value(sym.assignable[-1])
             no_changes = False
 
     # Handle choices
 
     for choice in choices:
-        # Handle a choice whose visibility allows it to be in "y" mode
+        # Handle a choice whose visibility allows it to be in y mode
 
         if choice.visibility == 2:
             selection = choice.default_selection
@@ -88,7 +88,7 @@ while 1:
                selection is not choice.user_selection:
 
                 # Yup, select it
-                selection.set_value("y")
+                selection.set_value(2)
                 no_changes = False
 
         # Handle a choice whose visibility only allows it to be in "m" mode.
@@ -100,10 +100,10 @@ while 1:
 
                 # Does the choice have a symbol that can be "m" that we haven't
                 # already set to "m"?
-                if sym.user_tri_value != 1 and "m" in sym.assignable:
+                if sym.user_tri_value != 1 and 1 in sym.assignable:
 
                     # Yup, set it
-                    sym.set_value("m")
+                    sym.set_value(1)
                     no_changes = False
 
     if no_changes:
diff --git a/examples/defconfig.py b/examples/defconfig.py
index ce2bf6e..236db8d 100644
--- a/examples/defconfig.py
+++ b/examples/defconfig.py
@@ -8,7 +8,7 @@ import kconfiglib
 import os
 import sys
 
-conf = kconfiglib.Config(sys.argv[1])
+conf = kconfiglib.Kconfig(sys.argv[1])
 
 if os.path.exists(".config"):
     print("using existing .config")
diff --git a/examples/defconfig_oldconfig.py b/examples/defconfig_oldconfig.py
index 98173e7..8e72c8a 100644
--- a/examples/defconfig_oldconfig.py
+++ b/examples/defconfig_oldconfig.py
@@ -15,7 +15,7 @@
 import kconfiglib
 import sys
 
-conf = kconfiglib.Config(sys.argv[1])
+conf = kconfiglib.Kconfig(sys.argv[1])
 
 # Mirrors defconfig
 conf.load_config("arch/x86/configs/x86_64_defconfig")
@@ -23,15 +23,15 @@ conf.write_config(".config")
 
 # Mirrors the first oldconfig
 conf.load_config(".config")
-conf.syms["ETHERNET"].set_value('n')
+conf.syms["ETHERNET"].set_value(0)
 conf.write_config(".config")
 
 # Mirrors the second oldconfig
 conf.load_config(".config")
-conf.syms["ETHERNET"].set_value('y')
+conf.syms["ETHERNET"].set_value(2)
 for s in conf:
-    if s.user_value is None and 'n' in s.assignable:
-        s.set_value('n')
+    if s.user_value is None and 0 in s.assignable:
+        s.set_value(0)
 
 # Write the final configuration
 conf.write_config(".config")
diff --git a/examples/eval_expr.py b/examples/eval_expr.py
index a907f35..be02c77 100644
--- a/examples/eval_expr.py
+++ b/examples/eval_expr.py
@@ -13,10 +13,10 @@ if len(sys.argv) < 3:
     print('Pass symbol name (without "CONFIG_" prefix) with SCRIPT_ARG=NAME')
     sys.exit(1)
 
-conf = kconfiglib.Config(sys.argv[1])
+conf = kconfiglib.Kconfig(sys.argv[1])
 
 # Enable modules so that 'm' doesn't get demoted to 'n'
-conf.syms["MODULES"].set_value("y")
+conf.syms["MODULES"].set_value(2)
 
 print("the expression '{}' evaluates to {}"
       .format(sys.argv[2], conf.eval_string(sys.argv[2])))
diff --git a/examples/help_grep.py b/examples/help_grep.py
index 6fcb08f..6f54583 100644
--- a/examples/help_grep.py
+++ b/examples/help_grep.py
@@ -33,7 +33,7 @@
 #   ...
 
 
-from kconfiglib import Config, Symbol, Choice, MENU, COMMENT
+from kconfiglib import Kconfig, Symbol, Choice, MENU, COMMENT
 import re
 import sys
 
@@ -68,5 +68,5 @@ def search_tree(node):
 
         node = node.next
 
-conf = Config(sys.argv[1])
+conf = Kconfig(sys.argv[1])
 search_tree(conf.top_node)
diff --git a/examples/print_sym_info.py b/examples/print_sym_info.py
index 2c1b0f0..cc9f50a 100644
--- a/examples/print_sym_info.py
+++ b/examples/print_sym_info.py
@@ -5,48 +5,49 @@
 #   $ make [ARCH=<arch>] scriptconfig SCRIPT=Kconfiglib/examples/print_sym_info.py SCRIPT_ARG=<name>
 #
 # Example output for SCRIPT_ARG=modules:
-# 
-#   config MODULES
-#   	bool
-#   	prompt "Enable loadable module support"
-#   	option modules
-#   	help
-#   	  Kernel modules are small pieces of compiled code which can
-#   	  be inserted in the running kernel, rather than being
-#   	  permanently built into the kernel.  You use the "modprobe"
-#   	  tool to add (and sometimes remove) them.  If you say Y here,
-#   	  many parts of the kernel can be built as modules (by
-#   	  answering M instead of Y where indicated): this is most
-#   	  useful for infrequently used options which are not required
-#   	  for booting.  For more information, see the man pages for
-#   	  modprobe, lsmod, modinfo, insmod and rmmod.
-#   	  
-#   	  If you say Y here, you will need to run "make
-#   	  modules_install" to put the modules under /lib/modules/
-#   	  where modprobe can find them (you may need to be root to do
-#   	  this).
-#   	  
-#   	  If unsure, say Y.
 #
-#   value = n
-#   visibility = y
-#   currently assignable values: n, y
-#   defined at init/Kconfig:1678
+# menuconfig MODULES
+# 	bool
+# 	prompt "Enable loadable module support"
+# 	option modules
+# 	help
+# 	  Kernel modules are small pieces of compiled code which can
+# 	  be inserted in the running kernel, rather than being
+# 	  permanently built into the kernel.  You use the "modprobe"
+# 	  tool to add (and sometimes remove) them.  If you say Y here,
+# 	  many parts of the kernel can be built as modules (by
+# 	  answering M instead of Y where indicated): this is most
+# 	  useful for infrequently used options which are not required
+# 	  for booting.  For more information, see the man pages for
+# 	  modprobe, lsmod, modinfo, insmod and rmmod.
+# 	  
+# 	  If you say Y here, you will need to run "make
+# 	  modules_install" to put the modules under /lib/modules/
+# 	  where modprobe can find them (you may need to be root to do
+# 	  this).
+# 	  
+# 	  If unsure, say Y.
+# 
+# value = n
+# visibility = y
+# currently assignable values: n, y
+# defined at init/Kconfig:1674
 
-import kconfiglib
+from kconfiglib import Kconfig, TRI_TO_STR
 import sys
 
 if len(sys.argv) < 3:
     print('Pass symbol name (without "CONFIG_" prefix) with SCRIPT_ARG=<name>')
     sys.exit(1)
 
-conf = kconfiglib.Config(sys.argv[1])
+conf = Kconfig(sys.argv[1])
 sym = conf.syms[sys.argv[2]]
 
 print(sym)
-print("value = " + sym.value)
-print("visibility = " + sym.visibility)
-print("currently assignable values: " + ", ".join(sym.assignable))
+print("value = " + sym.str_value)
+print("visibility = " + TRI_TO_STR[sym.visibility])
+print("currently assignable values: " +
+      ", ".join([TRI_TO_STR[v] for v in sym.assignable]))
 
 for node in sym.nodes:
     print("defined at {}:{}".format(node.filename, node.linenr))
diff --git a/examples/print_tree.py b/examples/print_tree.py
index 8d18ce9..9d9eac2 100644
--- a/examples/print_tree.py
+++ b/examples/print_tree.py
@@ -38,7 +38,7 @@
 #     config GENERIC_IRQ_PROBE
 #   ...
 
-from kconfiglib import Config, Symbol, Choice, MENU, COMMENT
+from kconfiglib import Kconfig, Symbol, Choice, MENU, COMMENT
 import sys
 
 def indent_print(s, indent):
@@ -63,5 +63,5 @@ def print_items(node, indent):
 
         node = node.next
 
-conf = Config(sys.argv[1])
+conf = Kconfig(sys.argv[1])
 print_items(conf.top_node, 0)
diff --git a/kconfiglib.py b/kconfiglib.py
index 1bf61a6..96a421c 100644
--- a/kconfiglib.py
+++ b/kconfiglib.py
@@ -9,127 +9,290 @@ from Kconfig-based configuration systems. Features include the following:
 
  - Reading/writing of .config files
 
- - Inspection of symbol properties: print()ing a symbol (which calls __str__())
-   produces output which could be fed back into a Kconfig parser to redefine
-   the symbol, and __str__() is implemented with only public APIs.
+ - Inspection of symbol properties and expressions: printing a symbol (calling
+   Symbol.__str__()) gives output which could be fed back into a Kconfig parser
+   to redefine the symbol, and __str__() is implemented with only public APIs.
 
-   A helpful __repr__() is implemented on all objects as well.
+   A helpful __repr__() is implemented on all objects as well, also implemented
+   with public APIs.
 
- - Expression inspection and evaluation: All expressions are exposed and use a
-   simple tuple-based format that can be processed manually if needed.
+ - Expressions use a simple tuple-based format and can be processed manually if
+   needed.
 
  - Menu tree inspection: The underlying menu tree is exposed, including
    submenus created implicitly from symbols depending on preceding symbols.
    This can be used e.g. to implement menuconfig-like functionality.
 
  - Runs under both Python 2 and 3. The code mostly uses basic Python features
-   (the most advanced things used are probably @property and __slots__).
+   and has no third-party dependencies (the most advanced things used are
+   @property and __slots__).
 
  - Robust and highly compatible with the standard Kconfig C tools: The test
-   suite automatically compares the output from Kconfiglib with the output from
-   the C tools on the real kernel Kconfig and defconfig files for all ARCHes.
-   The comparison is done by diffing the generated .config files to make sure
-   they're identical. All tests are expected to pass.
+   suite automatically compares output from Kconfiglib and the C tools (by
+   diffing generated .config files) on the real kernel Kconfig and defconfig
+   files, for all ARCHes. All tests are expected to pass.
 
-   A suite of self tests is also included.
+   A set of selftests is also included.
 
- - Internals that (mostly) mirror the C implementation. A lot can indirectly be
-   learned about how it works by reading the Kconfiglib documentation and code.
+ - Not horribly slow despite being a pure Python implementation: Parses the x86
+   Kconfigs in about a second on a Core i7 2600K (with a warm file cache). For
+   long-running jobs, PyPy gives a big performance boost.
 
- - Pretty speedy by pure Python standards: Parses the x86 Kconfigs in about a
-   second on a Core i7 2600K (with a warm file cache). For long-running jobs,
-   PyPy gives a large performance boost.
+ - Internals that (mostly) mirror the C implementation while being simpler to
+   understand.
 
 
-Using Kconfiglib on the Linux kernel
-====================================
+Using Kconfiglib on the Linux kernel with the Makefile targets
+==============================================================
 
 For the Linux kernel, a handy interface is provided by the
-scripts/kconfig/Makefile patch.
+scripts/kconfig/Makefile patch, which adds the following targets:
 
-Use the 'iscriptconfig' target for experimentation. It gives an interactive
-Python prompt where the configuration for ARCH has been preloaded.
 
-  $ make [ARCH=<arch>] [PYTHONCMD=<python/python3/pypy/...>] iscriptconfig
+make iscriptconfig
+------------------
 
-To run a script, use the 'scriptconfig' target.
+This target gives an interactive Python prompt where the configuration for ARCH
+has been preloaded and is available in 'kconf'.
 
-  $ make [ARCH=<arch>] [PYTHONCMD=<python/python3/pypy/...>] scriptconfig SCRIPT=<path to script> [SCRIPT_ARG=<arg>]
+To get a feel for the API, try evaluating and printing the symbols in
+kconf.defined_syms, and explore the menu tree starting at kconf.top_node by
+following 'next' and 'list' pointers.
 
-PYTHONCMD is the Python interpreter to use. It defaults to "python".
+The item contained in the menu node is found in MenuNode.item, and all symbols
+and choices have a 'nodes' attribute which gives their menu nodes (usually only
+one).
+
+If you want to look up a symbol by name, use the kconf.syms dictionary.
+
+
+As usual, ARCH=<arch> can be passed to 'make' to select the arch.
+PYTHONCMD=<executable> selects the Python executable to use (default:
+"python").
 
 Tip: IronPython (PYTHONCMD=ipython) autocompletion is handy when figuring out
-the API.
+the API, as it provides autocompletion for attributes.
+
 
+make scriptconfig SCRIPT=<script> [SCRIPT_ARG=<arg>]
+----------------------------------------------------
 
-Writing scriptconfig scripts
-----------------------------
+This target runs the Python script given by the SCRIPT parameter on the
+configuration. sys.argv[1] holds the name of the top-level Kconfig file, and
+sys.argv[2] the SCRIPT_ARG argument, if given.
 
 See the examples/ subdirectory for example scripts.
 
-Scripts receive the name of the Kconfig file to load in sys.argv[1]. As far as
-I can tell, this is always "Kconfig" from the kernel top-level directory as of
-Linux 4.14. If an argument is provided with SCRIPT_ARG, it appears as
-sys.argv[2].
 
+Using Kconfiglib without the Makefile targets
+=============================================
+
+The make targets are only needed for a trivial reason: The Kbuild makefiles
+export environment variables which are referenced inside the Kconfig files (via
+'option env="ENV_VARIABLE"').
+
+In practice, the only variables referenced (as of writing, and for many years)
+are ARCH, SRCARCH, and KERNELVERSION. To run Kconfiglib without the Makefile
+patch, do this:
+
+  $ ARCH=x86 SRCARCH=x86 KERNELVERSION=`make kernelversion` python
+  >>> import kconfiglib
+  >>> kconf = kconfiglib.Kconfig()  # filename defaults to "Kconfig"
+
+Search the top-level Makefile for "Additional ARCH settings" to see other
+possibilities for ARCH and SRCARCH. Kconfiglib will print a warning if an unset
+environment variable is referenced inside the Kconfig files.
+
+
+Gotcha
+******
+
+It's important to set $SRCARCH even if you don't care about values and only
+want to extract information from Kconfig files, because the top-level Makefile
+does this (as of writing):
+
+  source "arch/$SRCARCH/Kconfig"
+
+If $SRCARCH is not set, this expands to "arch//Kconfig", and arch/Kconfig
+happens to be an existing file, giving something that appears to work but is
+actually a truncated configuration.
+
+
+Intro to symbol values
+======================
+
+Kconfiglib has the same assignment semantics as the C implementation.
+
+Any symbol can be assigned a value by the user (via Kconfig.load_config() or
+Symbol.set_value()), but this user value is only respected if the symbol is
+visible, which corresponds to it (currently) being visible in the menuconfig
+interface.
+
+Symbols without prompts are never visible (setting a user value on them is
+pointless). For symbols with prompts, the visibility of the symbol is
+determined by the condition on the prompt.
+
+Dependencies from parents and 'if'/'depends on' are propagated to properties,
+including prompts, so these two configurations are logically equivalent:
+
+(1)
+
+  menu "menu"
+  depends on A
+
+  if B
+
+  config FOO
+      tristate "foo" if D
+      default y
+      depends on C
+
+  endif
+
+  endmenu
+
+(2)
+
+  menu "menu"
+  depends on A
+
+  config FOO
+      tristate "foo" if A && B && C && D
+      default y if A && B && C
+
+  endmenu
 
-Running Kconfiglib without the Makefile patch
----------------------------------------------
+In this example, A && B && C && D (the prompt condition) needs to be m or y for
+FOO to be visible (assignable). If the value is m, the symbol can only be
+assigned the value m. The visibility sets an upper bound on the value that can
+be assigned by the user. Any higher user value will be truncated down.
 
-The Makefile patch is used to pick up the ARCH, SRCARCH, and KERNELVERSION
-environment variables (and any future environment variables that might get
-used). If you want to run Kconfiglib without the Makefile patch, the following
-will probably work in practice (it's what the test suite does in 'speedy' mode,
-except it tests all ARCHes and doesn't bother setting KERNELVERSION to a sane
-value to save some time on startup).
+'default' properties are independent of the visibility, though a 'default' will
+often get the same condition as the prompt due to dependency propagation.
+'default' properties are used if the symbol is not visible or has no user
+value.
 
-  $ ARCH=x86 SRCARCH=x86 KERNELVERSION=`make kernelversion` python script.py
+Symbols with no (active) user value and no (active) 'default' default to n for
+bool/tristate symbols, and to the empty string for other symbols.
 
-ARCH and SRCARCH (the arch/ subdirectory) might differ in some cases. Search
-for "Additional ARCH settings for" in the top-level Makefile to see the
-possible variations. The value of KERNELVERSION doesn't seem to matter as of
-Linux 4.14.
+'select' works similarly to symbol visibility, but sets a lower bound on the
+value of the symbol instead. The lower bound is determined by the value of the
+select*ing* symbol. 'select' does not respect visibility, so non-visible
+symbols can be forced to a particular (minimum) value by a select as well.
 
-Kconfiglib will warn if you forget to set some environment variable that's
-referenced in a Kconfig file (via 'option env="ENV_VAR"').
+For non-bool/tristate choices, it only matters if the visibility is n or not: m
+visibility works the same as y visibility.
 
+Conditions on 'default' and 'select' work in mostly intuitive ways. If the
+condition is n, the 'default' or 'select' is disabled. If it is m, the
+'default' or 'select' value (the value of the selecting symbol) is truncated
+down to m.
 
-Expression format
-=================
+When writing a configuration with Kconfig.write_config(), only symbols that are
+visible, have an (active) default, or are selected will get written out (note
+that this includes all symbols that would accept user values). Kconfiglib
+matches the .config format produced by the C implementations down to the
+character. This eases testing.
+
+In Kconfiglib, the set of (currently) assignable values for a bool/tristate
+symbol appear in Symbol.assignable. For other symbol types, just check if
+sym.visibility is non-0 (non-n).
+
+
+Intro to the menu tree
+======================
+
+The menu structure, as seen in e.g. menuconfig, is represented by a tree of
+MenuNode objects. The top node of the configuration corresponds to an implicit
+top-level menu, the title of which is shown at the top in the menuconfig
+interface. (The title with variables expanded is available in
+Kconfig.mainmenu_text in Kconfiglib.)
+
+The top node is found in Kconfig.top_node. From there, you can visit child menu
+nodes by following the 'list' pointer, and any following menu nodes by
+following the 'next' pointer. Usually, a non-None 'list' pointer indicates a
+menu or Choice, but menu nodes for symbols can sometimes have a non-None 'list'
+pointer too due to menus created implicitly from dependencies.
+
+MenuNode.item is either a Symbol or a Choice object, or one of the constants
+MENU and COMMENT. The prompt of the menu node (which also holds the text for
+menus and comments) can be found in MenuNode.prompt. For Symbol and Choice,
+MenuNode.help holds the help text (if any, otherwise None).
+
+This organization mirrors the C implementation. MenuNode is called
+'struct menu' there, but I thought "menu" was a confusing name.
+
+Note that prompts and help texts for symbols and choices are stored in the menu
+node. This makes it possible to define a symbol in multiple locations with a
+different prompt or help text in each location.
+
+The list of menu nodes for a Symbol or Choice can be found in the
+Symbol/Choice.nodes attribute.
+
+It is possible to give a Choice a name and define it in multiple locations,
+hence why Choice.nodes is a list. You're unlikely to ever see a choice defined
+in multiple locations in practice though (I don't think I've even seen a named
+choice outside of the test suite).
+
+
+Intro to expressions
+====================
+
+Expressions can be evaluated with the expr_value() function and printed with
+the expr_str() function (these are used internally as well).
 
 The following table should help you figure out how expressions are represented.
-A, B, C, ... are symbols (Symbol instances) or strings (which represent
-constant symbols). NOT is the kconfiglib.NOT constant, etc.
+A, B, C, ... are symbols (Symbol instances), NOT is the kconfiglib.NOT
+constant, etc.
 
 Expression            Representation
 ----------            --------------
 A                     A
+"A"                   A (constant symbol)
 !A                    (NOT, A)
 A && B                (AND, A, B)
+A && B && C           (AND, A, (AND, B, C))
 A || B                (OR, A, B)
+A || (B && C && D)    (OR, A, (AND, B, (AND, C, D)))
 A = B                 (EQUAL, A, B)
 A != "foo"            (UNEQUAL, A, "foo")
-A || (B && C && D)    (OR, A, (AND, B, (AND, C, D)))
-y                     config.y
-"y"                   config.y
+A && B = C && D       (AND, A, (AND, (EQUAL, B, C), D))
+n                     Kconfig.n (constant symbol)
+m                     Kconfig.m (constant symbol)
+y                     Kconfig.y (constant symbol)
+"y"                   Kconfig.y (constant symbol)
+
+Strings like "foo" in 'default "foo"' or 'depends on SYM = "foo"' are
+represented as constant symbols, so the only values that appear in expressions
+are symbols (this mirrors the C implementation).
+
+Manual evaluation examples:
+
+  - The value of A && B is min(A.tri_value, B.tri_value)
+
+  - The value of A || B is max(A.tri_value, B.tri_value)
+
+  - The value of A = B is y if A.str_value == B.str_value, and n otherwise.
+    Note that str_value is used here instead of tri_value.
+
+n/m/y are automatically converted to the corresponding constant symbols
+"n"/"m"/"y" (Kconfig.n/m/y) during parsing.
 
-TODO: show example for other constant symbols
+A "missing" condition (e.g. <cond> if the 'if <cond>' part is removed from
+'default A if <cond>') or other "missing" expression is represented as
+Kconfig.y. The standard __str__() functions avoid printing 'if y' conditions to
+give cleaner output.
 
-As seen in the final two examples, n/m/y are always represented as the constant
-symbols config.n/m/y, regardless of whether they're written with or without
-quotes. 'config' represents the Config instance of the configuration the
-expression appears in.
+Kconfig.const_syms is a dictionary like Kconfig.syms but for constant symbols.
 
-A missing expression (e.g. <cond> if the 'if <cond>' part is removed from
-'default A if <conf>') is represented as config.y. The standard __str__()
-functions avoid printing 'if y' conditions to give cleaner output.
 
+Feedback
+========
 
 Send bug reports, suggestions, and questions to ulfalizer a.t Google's email
-service (or open a ticket on the GitHub page).
+service, or open a ticket on the GitHub page.
 """
 
-# TODO: document n/m/y
 # TODO: consistent docstring format
 
 import errno
@@ -152,73 +315,76 @@ import sys
 # Public classes
 #
 
-class Config(object):
+class Kconfig(object):
     """
     Represents a Kconfig configuration, e.g. for x86 or ARM. This is the set of
     symbols, choices, and menu nodes appearing in the configuration. Creating
-    any number of Config objects (including for different architectures) is
+    any number of Kconfig objects (including for different architectures) is
     safe. Kconfiglib doesn't keep any global state.
 
-    The following attributes are available on Config instances. They should be
-    viewed as read-only, and some are implemented through @property magic.
+    The following attributes are available. They should be treated as
+    read-only, and some are implemented through @property magic.
 
     syms:
-      A dictionary with all symbols in the configuration. The key is the name
-      of the symbol, so that e.g. conf.syms["FOO"] returns the Symbol instance
-      for the symbol FOO. Symbols that are referenced in expressions but never
-      defined also appear in 'syms'.
-
-      Constant symbols, e.g. "foo" in 'A = "foo"', are not included in
-      Config.syms.
+      A dictionary with all symbols in the configuration, indexed by name. Also
+      includes all symbols that are referenced in expressions but never
+      defined, except for constant (quoted) symbols.
 
-    defined_syms:
-      A list of all defined symbols, in the same order as they appear in the
-      Kconfig files. Provided as a convenience. The defined symbols are those
-      whose 'nodes' attribute is non-empty.
+    const_syms:
+      A dictionary like 'syms' for constant (quoted) symbols.
 
     named_choices:
       A dictionary like 'syms' for named choices (choice FOO). This is for
-      completeness. I've never seen named choices being used.
+      completeness. I've never seen a named choice outside of the test suite.
+
+    defined_syms:
+      A list with all defined symbols, in the same order as they appear in the
+      Kconfig files. Provided as a convenience.
+
+    n/m/y:
+      The predefined constant symbols n/m/y. Also available in const_syms.
 
     modules:
-      The Symbol instance for the modules symbol. This is currently hardcoded
-      to MODULES, which is backwards compatible, and Kconfiglib will warn if
-      'option modules' is specified on some other symbol. Tell me if you need
-      proper 'option modules' support.
+      The Symbol instance for the modules symbol. Currently hardcoded to
+      MODULES, which is backwards compatible. Kconfiglib will warn if
+      'option modules' is set on some other symbol. Tell me if you need proper
+      'option modules' support.
+
+      'modules' is never None. If the MODULES symbol is not explicitly defined,
+      it will get the value n as expected.
 
-      Never None.
+      A simple way to enable modules is to do 'kconf.modules.set_value(2)'
+      (provided the MODULES symbol is defined and visible). Modules are
+      disabled by default in the kernel Kconfig files as of writing, though
+      nearly all defconfig files enable them (with 'CONFIG_MODULES=y').
 
     defconfig_list:
       The Symbol instance for the 'option defconfig_list' symbol, or None if no
       defconfig_list symbol exists. The defconfig filename derived from this
-      symbol can be found in Config.defconfig_filename.
-
-      Setting 'option defconfig_list' on multiple symbols ignores the setting
-      on all symbols after the first.
+      symbol can be found in Kconfig.defconfig_filename.
 
     defconfig_filename:
-      The filename given by the 'option defconfig_list' symbol. This is taken
-      from the first 'default' with a satisfied condition where the file
-      specified by the 'default' exists. If a defconfig file foo/defconfig is
-      not found and $srctree was set when the Config was created,
+      The filename given by the defconfig_list symbol. This is taken from the
+      first 'default' with a satisfied condition where the specified file
+      exists (can be opened for reading). If a defconfig file foo/defconfig is
+      not found and $srctree was set when the Kconfig was created,
       $srctree/foo/defconfig is looked up as well.
 
-      None if either no defconfig_list symbol exists, or if the defconfig_list
-      symbol has no 'default' with a satisfied condition that points to an
-      existing file.
+      References to Kconfig symbols ("$FOO") in the 'default' properties of the
+      defconfig_filename symbol are are expanded before the file is looked up.
 
-      References to Kconfig symbols ("$FOO") are expanded in 'default'
-      properties.
+      'defconfig_filename' is None if either no defconfig_list symbol exists,
+      or if the defconfig_list symbol has no 'default' with a satisfied
+      condition that specifies a file that exists.
 
-      Something to look out for is that scripts/kconfig/Makefile might pass
-      --defconfig=<defconfig> to scripts/kconfig/conf when running e.g.
-      'make defconfig'. This option overrides the defconfig_list symbol,
-      meaning defconfig_filename might not match what 'make defconfig' would
-      use in those cases.
+      Gotcha: scripts/kconfig/Makefile might pass --defconfig=<defconfig> to
+      scripts/kconfig/conf when running e.g. 'make defconfig'. This option
+      overrides the defconfig_list symbol, meaning defconfig_filename might not
+      always match what 'make defconfig' would use.
 
     top_node:
-      The menu node (see the MenuNode class) of the top-level menu. Acts as the
-      root of the menu tree.
+      The menu node (see the MenuNode class) of the implicit top-level menu.
+      Acts as the root of the menu tree.
 
     mainmenu_text:
       The prompt (title) of the top_node menu, with Kconfig variable references
@@ -230,10 +396,10 @@ class Config(object):
       The value of the $srctree environment variable when the configuration was
       loaded, or None if $srctree wasn't set. Kconfig and .config files are
       looked up relative to $srctree if they are not found in the base path
-      (unless absolute paths are specified). This is to support out-of-tree
-      builds. The C tools use this variable in the same way.
+      (unless absolute paths are used). This is used to support out-of-tree
+      builds. The C tools use this environment variable in the same way.
 
-      Changing $srctree after creating the Config instance has no effect. Only
+      Changing $srctree after creating the Kconfig instance has no effect. Only
       the value when the configuration is loaded matters. This avoids surprises
       if multiple configurations are loaded with different values for $srctree.
 
@@ -284,7 +450,7 @@ class Config(object):
 
     def __init__(self, filename="Kconfig", warn=True):
         """
-        Creates a new Config object by parsing Kconfig files. Raises
+        Creates a new Kconfig object by parsing Kconfig files. Raises
         KconfigSyntaxError on syntax errors. Note that Kconfig files are not
         the same as .config files (which store configuration symbol values).
 
@@ -299,12 +465,12 @@ class Config(object):
           always "Kconfig" in practice.
 
           The $srctree environment variable is used to look up Kconfig files if
-          set (see the class documentation).
+          set. See the class documentation.
 
         warn (default: True):
           True if warnings related to this configuration should be printed to
           stderr. This can be changed later with
-          Config.enable/disable_warnings(). It is provided as a constructor
+          Kconfig.enable/disable_warnings(). It is provided as a constructor
           argument since warnings might be generated during parsing.
         """
 
@@ -337,7 +503,7 @@ class Config(object):
             sym.config = self
             sym.name = nmy
             sym.is_constant = True
-            sym._type = TRISTATE
+            sym.orig_type = TRISTATE
             sym._cached_tri_val = STR_TO_TRI[nmy]
             sym._cached_str_val = nmy
 
@@ -347,26 +513,28 @@ class Config(object):
         self.m = self.const_syms["m"]
         self.y = self.const_syms["y"]
 
-        # Just to make n/m/y well-formed symbols
+        # Make n/m/y well-formed symbols
         for nmy in "n", "m", "y":
             sym = self.const_syms[nmy]
             sym.rev_dep = sym.weak_rev_dep = sym.direct_dep = self.n
 
+        # This is used to determine whether previously unseen symbols should be
+        # registered. They shouldn't be if we parse expressions after parsing,
+        # as part of Kconfig.eval_string().
         self._parsing_kconfigs = True
 
         self.modules = self._lookup_sym("MODULES")
         self.defconfig_list = None
 
-        # Predefined symbol. DEFCONFIG_LIST uses this.
+        # The only predefined symbol besides n/m/y. DEFCONFIG_LIST uses this as
+        # of writing.
         uname_sym = self._lookup_const_sym("UNAME_RELEASE")
-        uname_sym._type = STRING
+        uname_sym.orig_type = STRING
         # env_var doubles as the SYMBOL_AUTO flag from the C implementation, so
-        # just set it to something. The naming breaks a bit here, but it's
-        # pretty obscure.
+        # just set it to something. The naming breaks a bit here.
         uname_sym.env_var = "<uname release>"
         uname_sym.defaults.append(
-            (self._lookup_const_sym(platform.uname()[2]),
-             self.y))
+            (self._lookup_const_sym(platform.uname()[2]), self.y))
         self.syms["UNAME_RELEASE"] = uname_sym
 
         self.top_node = MenuNode()
@@ -381,12 +549,20 @@ class Config(object):
 
         # Parse the Kconfig files
 
+        # These implements a single line of "unget" for the parser
         self._reuse_line = False
         self._has_tokens = False
 
+        # Keeps track of the location in the parent Kconfig files. Kconfig
+        # files usually source other Kconfig files.
         self._filestack = []
 
-        self._enter_file_empty_stack(filename)
+        # The current parsing location
+        self._filename = filename
+        self._linenr = 0
+
+        self._file = self._open(filename)
+
         self._parse_block(None,           # end_token
                           self.top_node,  # parent
                           self.y,         # visible_if_deps
@@ -396,8 +572,7 @@ class Config(object):
 
         self._parsing_kconfigs = False
 
-        # Do various post-processing of the menu tree, e.g. to finalize
-        # choices, flatten ifs, and implicitly create menus
+        # Do various post-processing of the menu tree
         _finalize_tree(self.top_node)
 
         # Build Symbol._direct_dependents for all symbols
@@ -408,7 +583,7 @@ class Config(object):
         """
         See the class documentation.
         """
-        return self._expand_sym_refs(self.top_node.prompt[0])
+        return self._expand_syms(self.top_node.prompt[0])
 
     @property
     def defconfig_filename(self):
@@ -420,9 +595,8 @@ class Config(object):
 
         for filename, cond in self.defconfig_list.defaults:
             if expr_value(cond):
-                filename = self._expand_sym_refs(filename.str_value)
                 try:
-                    with self._open(filename) as f:
+                    with self._open(self._expand_syms(filename.str_value)) as f:
                         return f.name
                 except IOError:
                     continue
@@ -434,12 +608,12 @@ class Config(object):
         Loads symbol values from a file in the .config format. Equivalent to
         calling Symbol.set_value() to set each of the values.
 
-        "# CONFIG_FOO is not set" within a .config file is treated specially
-        and sets the user value of FOO to 'n'. The C tools work the same way.
+        "# CONFIG_FOO is not set" within a .config file sets the user value of
+        FOO to n. The C tools work the same way.
 
         filename:
-          The .config file to load. The $srctree variable is used if set (see
-          the class documentation).
+          The file to load. Respects $srctree if set (see the class
+          documentation).
 
         replace (default: True): True if all existing user values should
           be cleared before loading the .config.
@@ -470,26 +644,45 @@ class Config(object):
                         continue
 
                     sym = syms[name]
+                    if not sym.nodes:
+                        self._warn_undef_assign_load(name, val, filename,
+                                                     linenr)
+                        continue
 
-                    if sym._type == STRING and val.startswith('"'):
-                        if len(val) < 2 or val[-1] != '"':
-                            self._warn("malformed string literal",
-                                       filename, linenr)
+                    if sym.orig_type in (BOOL, TRISTATE):
+                        # The C implementation only checks the first character
+                        # to the right of '=', for whatever reason
+                        if not ((sym.orig_type == BOOL and
+                                 val.startswith(("n", "y"))) or \
+                                (sym.orig_type == TRISTATE and
+                                 val.startswith(("n", "m", "y")))):
+                            self._warn("'{}' is not a valid value for the {} "
+                                       "symbol {}. Assignment ignored."
+                                       .format(val, _TYPENAME[sym.orig_type],
+                                               sym.name))
                             continue
 
-                        # Strip quotes and remove escapings. The unescaping
-                        # procedure should be safe since " can only appear as
-                        # \" inside the string.
-                        val = val[1:-1].replace('\\"', '"') \
-                                       .replace("\\\\", "\\")
-
-                    if sym.choice is not None:
-                        mode = sym.choice.user_str_value
-                        if mode is not None and mode != val:
-                            self._warn("assignment to {} changes mode of "
-                                       'containing choice from "{}" to "{}".'
-                                       .format(name, val, mode),
+                        if sym.choice is not None:
+                            mode = sym.choice.user_str_value
+                            if mode is not None and mode != val:
+                                self._warn("assignment to {} changes mode of "
+                                           'containing choice from {} to {}.'
+                                           .format(name, mode, val),
+                                           filename, linenr)
+
+                        # We represent tristate values as 0, 1, 2
+                        val = STR_TO_TRI[val[0]]
+
+                    elif sym.orig_type == STRING:
+                        string_match = _conf_string_re_match(val)
+                        if not string_match:
+                            self._warn("Malformed string literal in "
+                                       "assignment to {}. Assignment ignored."
+                                       .format(sym.name),
                                        filename, linenr)
+                            continue
+
+                        val = unescape(string_match.group(1))
 
                 else:
                     unset_match = unset_re_match(line)
@@ -503,14 +696,24 @@ class Config(object):
                         continue
 
                     sym = syms[name]
-                    val = "n"
+                    if sym.orig_type not in (BOOL, TRISTATE):
+                        continue
+
+                    val = 0
 
                 # Done parsing the assignment. Set the value.
 
                 if sym.user_str_value is not None:
+                    # Make the format for the old and new value consistent in
+                    # the warning
+                    if sym.orig_type in (BOOL, TRISTATE):
+                        display_val = TRI_TO_STR[val]
+                    else:
+                        display_val = val
+
                     self._warn('{} set more than once. Old value: "{}", new '
                                'value: "{}".'
-                               .format(name, sym.user_str_value, val),
+                               .format(name, sym.user_str_value, display_val),
                                filename, linenr)
 
                 sym._set_value_no_invalidate(val, True)
@@ -518,17 +721,15 @@ class Config(object):
     def write_config(self, filename,
                      header="# Generated by Kconfiglib (https://github.com/ulfalizer/Kconfiglib)\n"):
         """
-        Writes out symbol values in .config format.
+        Writes out symbol values in the .config format.
 
-        Kconfiglib makes sure the format matches what the C tools would
-        generate, down to whitespace. This eases testing.
-
-        filename: The filename under which to save the configuration.
+        filename:
+          Self-explanatory.
 
-        header (default: "# Generated by Kconfiglib (https://github.com/ulfalizer/Kconfiglib)\n"):
-            Text that will be inserted verbatim at the beginning of the file.
-            You would usually want each line to start with '#' to make it a
-            comment, and include a final terminating newline.
+        header (default: "# Generated by Kconfiglib (https://github.com/ulfalizer/Kconfiglib)\\n"):
+          Text that will be inserted verbatim at the beginning of the file. You
+          would usually want each line to start with '#' to make it a comment,
+          and include a final terminating newline.
         """
         with open(filename, "w") as f:
             f.write(header)
@@ -536,44 +737,52 @@ class Config(object):
 
     def eval_string(self, s):
         """
-        Returns the value of the expression 's', represented as a string, in
-        the context of the configuration. Raises KconfigSyntaxError if syntax
-        errors are detected in 's'.
+        Returns the tristate value of the expression 's' represented as an
+        integer, where 0, 1, 2 correspond to n, m, and y, respectively. Raises
+        KconfigSyntaxError if syntax errors are detected in 's'. Warns if
+        undefined symbols are referenced.
 
         As an example, if FOO and BAR are tristate symbols at least one of
-        which has the value "y", then config.eval_string("y && (FOO || BAR)")
-        returns "y".
+        which has the value y, then config.eval_string("y && (FOO || BAR)")
+        returns 2 (y).
 
-        This function always yields a tristate value. To get the value of
-        non-bool, non-tristate symbols, use Symbol.str_value.
+        To get the string value of non-bool/tristate symbols, use
+        Symbol.str_value. eval_string() always returns a tristate value, and
+        all non-bool/tristate symbols have the tristate value 0 (n).
 
-        The result of this function is consistent with how evaluation works for
-        conditional ('if ...') expressions in the configuration (as well as in
-        the C tools). m is rewritten to 'm && MODULES'.
+        The expression parsing is consistent with how parsing works for
+        conditional ('if ...') expressions in the configuration, and matches
+        the C implementation. m is rewritten to 'm && MODULES', so
+        eval_string("m") will return 0 (n) unless modules are enabled.
         """
-        # TODO: explain
+        # The parser is optimized to be fast when parsing Kconfig files (where
+        # an expression can never appear at the beginning of a line). We have
+        # to monkey-patch things a bit here to reuse it.
+
         self._filename = None
 
         self._line = "if " + s
         self._tokenize()
+        # Remove the "if " to avoid giving confusing error messages
         self._line = s
+        # Remove the T_IF token
         del self._tokens[0]
 
-        return expr_value(self._parse_expr(True))
+        return expr_value(self._parse_expr(True))  # transform_m
 
     def unset_values(self):
         """
-        Resets the user values of all symbols, as if Config.load_config() or
+        Resets the user values of all symbols, as if Kconfig.load_config() or
         Symbol.set_value() had never been called.
         """
 
-        # set_value() already rejects undefined symbols, and they don't
-        # need to be invalidated (because their value never changes), so we can
-        # just iterate over defined symbols.
+        # set_value() already rejects undefined symbols, and they don't need to
+        # be invalidated (because their value never changes), so we can just
+        # iterate over defined symbols
 
         for sym in self.defined_syms:
-            # We're iterating over all symbols, so no need for symbols to
-            # invalidate their dependent symbols
+            # We're iterating over all (defined) symbols, so no need for
+            # symbols to invalidate their dependent symbols
             sym.user_str_value = sym.user_tri_value = None
             sym._invalidate()
 
@@ -584,20 +793,20 @@ class Config(object):
 
     def enable_warnings(self):
         """
-        See Config.__init__().
+        See Kconfig.__init__().
         """
         self._print_warnings = True
 
     def disable_warnings(self):
         """
-        See Config.__init__().
+        See Kconfig.__init__().
         """
         self._print_warnings = False
 
     def enable_undef_warnings(self):
         """
-        Enables printing of warnings to stderr for assignments to undefined
-        symbols. Disabled by default since it tends to be spammy for Kernel
+        Enables warnings for assignments to undefined symbols. Printed to
+        stderr. Disabled by default since they tend to be spammy for Kernel
         configurations (and mostly suggests cleanups).
         """
         self._print_undef_assign = True
@@ -610,9 +819,9 @@ class Config(object):
 
     def __repr__(self):
         """
-        Prints some general information when a Config object is evaluated.
+        Prints some general information when a Kconfig object is evaluated.
         """
-        fields = (
+        return "<{}>".format(", ".join((
             "configuration with {} symbols".format(len(self.syms)),
             'main menu prompt "{}"'.format(self.mainmenu_text),
             "srctree not set" if self.srctree is None else
@@ -621,14 +830,13 @@ class Config(object):
             "warnings " + ("enabled" if self._print_warnings else "disabled"),
             "undef. symbol assignment warnings " +
                 ("enabled" if self._print_undef_assign else "disabled"),
-        )
-
-        return "<{}>".format(", ".join(fields))
+        )))
 
     #
     # Private methods
     #
 
+
     #
     # File reading
     #
@@ -655,24 +863,121 @@ class Config(object):
             raise IOError(
                 'Could not open "{}" ({}: {}). Perhaps the $srctree '
                 "environment variable (which was {}) is set incorrectly. Note "
-                "that the current value of $srctree is saved when the Config "
+                "that the current value of $srctree is saved when the Kconfig "
                 "instance is created (for consistency and to cleanly "
                 "separate instances)."
                 .format(filename, errno.errorcode[e.errno], e.strerror,
                         "unset" if self.srctree is None else
                         '"{}"'.format(self.srctree)))
 
+    def _enter_file(self, filename):
+        """
+        Jumps to the beginning of a sourced Kconfig file, saving the previous
+        position and file object.
+        """
+        self._filestack.append((self._file, self._filename, self._linenr))
+        try:
+            self._file = self._open(filename)
+        except IOError as e:
+            # Extend the error message a bit in this case
+            raise IOError(
+                "{}:{}: {} Also note that e.g. $FOO in a 'source' "
+                "statement does not refer to the environment "
+                "variable FOO, but rather to the Kconfig Symbol FOO "
+                "(which would commonly have 'option env=\"FOO\"' in "
+                "its definition)."
+                .format(self._filename, self._linenr, e.message))
+
+        self._filename = filename
+        self._linenr = 0
+
+    def _leave_file(self):
+        """
+        Returns from a Kconfig file to the file that sourced it.
+        """
+        self._file.close()
+        self._file, self._filename, self._linenr = self._filestack.pop()
+
+    def _next_line(self):
+        """
+        Returns the next line in the current file, or the empty string at EOF
+        (like the standard readline() function)
+        """
+        # This provides a single line of "unget" if _reuse_line is set to True
+        if not self._reuse_line:
+            self._line = self._file.readline()
+            self._linenr += 1
+
+        self._reuse_line = False
+
+        # Handle line joining
+        while self._line.endswith("\\\n"):
+            self._line = self._line[:-2] + self._file.readline()
+            self._linenr += 1
+
+        return self._line
+
+    def _next_line_no_join(self):
+        """
+        Used for help texts, which don't do line joining
+        """
+        self._line = self._file.readline()
+        self._linenr += 1
+        return self._line
+
+
     #
-    # Kconfig parsing
+    # Tokenization
     #
 
+    def _lookup_sym(self, name):
+        """
+        Fetches the symbol 'name' from the symbol table, creating and
+        registering it if it does not exist. If '_parsing_configs' is False, it
+        means we're in eval_string(), and new symbols won't be registered.
+        """
+        if name in self.syms:
+            return self.syms[name]
+
+        sym = Symbol()
+        sym.config = self
+        sym.name = name
+        sym.is_constant = False
+        sym.rev_dep = sym.weak_rev_dep = sym.direct_dep = self.n
+
+        if self._parsing_kconfigs:
+            self.syms[name] = sym
+        else:
+            self._warn("no symbol {} in configuration".format(name))
+
+        return sym
+
+    def _lookup_const_sym(self, name):
+        """
+        Like _lookup_sym(), for constant (quoted) symbols
+        """
+        if name in self.const_syms:
+            return self.const_syms[name]
+
+        sym = Symbol()
+        sym.config = self
+        sym.name = name
+        sym.is_constant = True
+        sym.rev_dep = sym.weak_rev_dep = sym.direct_dep = self.n
+
+        if self._parsing_kconfigs:
+            self.const_syms[name] = sym
+
+        return sym
+
     def _tokenize(self):
         """
-        Parses Config._line, putting the tokens in Config._tokens. Registers
-        any new symbols encountered (via _lookup_sym()).
+        Parses Kconfig._line, putting the tokens in Kconfig._tokens. Registers
+        any new symbols encountered with _lookup(_const)_sym().
 
         Tries to be reasonably speedy by processing chunks of text via regexes
-        and string operations where possible. This is a hotspot during parsing.
+        and string operations where possible. This is the biggest hotspot
+        during parsing.
         """
 
         s = self._line
@@ -766,8 +1071,9 @@ class Config(object):
                 if c in "\"'":
                     # String literal/constant symbol
                     if "\\" not in s:
-                        # Fast path: If the string contains no backslashes, we
+                        # Fast path: If the line contains no backslashes, we
                         # can just find the matching quote.
+
                         end = s.find(c, i)
                         if end == -1:
                             self._parse_error("unterminated string")
@@ -775,8 +1081,9 @@ class Config(object):
                         val = s[i:end]
                         i = end + 1
                     else:
-                        # Slow path: This could probably be sped up, but it's a
-                        # very unusual case anyway.
+                        # Slow path for lines with backslashes (very rare,
+                        # performance irrelevant)
+
                         quote = c
                         val = ""
 
@@ -809,7 +1116,7 @@ class Config(object):
                             self._lookup_const_sym(val)
 
                 elif c == "&":
-                    # Invalid characters are ignored
+                    # Invalid characters are ignored (backwards-compatible)
                     if i >= len(s) or s[i] != "&":
                         continue
 
@@ -817,7 +1124,7 @@ class Config(object):
                     i += 1
 
                 elif c == "|":
-                    # Invalid characters are ignored
+                    # Invalid characters are ignored (backwards-compatible)
                     if i >= len(s) or s[i] != "|":
                         continue
 
@@ -860,7 +1167,7 @@ class Config(object):
                         token = _T_GREATER
 
                 else:
-                    # Invalid characters are ignored
+                    # Invalid characters are ignored (backwards-compatible)
                     continue
 
                 # Skip trailing whitespace
@@ -869,8 +1176,8 @@ class Config(object):
 
             self._tokens.append(token)
 
-        # TODO: say something about the None-termination
-
+        # None-terminating token streams makes the token fetching functions
+        # simpler/faster
         self._tokens.append(None)
         self._tokens_i = -1
 
@@ -882,56 +1189,48 @@ class Config(object):
         return self._tokens[self._tokens_i + 1]
 
     def _check_token(self, token):
+        """
+        Removes the next token if it's 'token' and returns True
+        """
         if self._tokens[self._tokens_i + 1] == token:
             self._tokens_i += 1
             return True
         return False
 
-    def _enter_file_empty_stack(self, filename):
-        try:
-            # TODO: comment
-            self._file = self._open(filename)
-        except IOError as e:
-            # Extend the error message a bit in this case
-            # TODO: broken for top-level Kconfig (because
-            # self._filename/_linenr isn't set)
-            raise IOError(
-                "{}:{}: {} Also note that e.g. $FOO in a 'source' "
-                "statement does not refer to the environment "
-                "variable FOO, but rather to the Kconfig Symbol FOO "
-                "(which would commonly have 'option env=\"FOO\"' in "
-                "its definition)."
-                .format(self._filename, self._linenr, e.message))
 
-        self._filename = filename
-        self._linenr = 0
+    #
+    # Parsing
+    #
 
-    def _enter_file(self, filename):
-        self._filestack.append((self._file, self._filename, self._linenr))
-        self._enter_file_empty_stack(filename)
+    def _make_and(self, e1, e2):
+        """
+        Constructs an AND (&&) expression. Performs trivial simplification.
+        """
+        if e1 is self.y:
+            return e2
 
-    def _leave_file(self):
-        self._file.close()
-        self._file, self._filename, self._linenr = self._filestack.pop()
+        if e2 is self.y:
+            return e1
 
-    def _next_line(self):
-        # This provides a single line of "unget" if _reuse_line is set to True
-        if not self._reuse_line:
-            self._line = self._file.readline()
-            self._linenr += 1
+        if e1 is self.n or e2 is self.n:
+            return self.n
 
-        self._reuse_line = False
+        return (AND, e1, e2)
 
-        while self._line.endswith("\\\n"):
-            self._line = self._line[:-2] + self._file.readline()
-            self._linenr += 1
+    def _make_or(self, e1, e2):
+        """
+        Constructs an OR (||) expression. Performs trivial simplification.
+        """
+        if e1 is self.n:
+            return e2
 
-        return self._line
+        if e2 is self.n:
+            return e1
 
-    def _next_line_no_join(self):
-        self._line = self._file.readline()
-        self._linenr += 1
-        return self._line
+        if e1 is self.y or e2 is self.y:
+            return self.y
+
+        return (OR, e1, e2)
 
     def _parse_block(self, end_token, parent, visible_if_deps, prev_node):
         """
@@ -953,21 +1252,23 @@ class Config(object):
 
         prev_node:
           The previous menu node. New nodes will be added after this one (by
-          modifying its 'next' pointer).
+          modifying their 'next' pointer).
 
-          Through a trick, prev_node is also used to parse a list of children
-          (for a menu or Choice): After parsing the children, the 'next'
-          pointer is assigned to the 'list' pointer to "tilt up" the children
-          above the node.
+          prev_node is reused to parse a list of child menu nodes (for a menu
+          or Choice): After parsing the children, the 'next' pointer is
+          assigned to the 'list' pointer to "tilt up" the children above the
+          node.
 
 
         Returns the final menu node in the block (or prev_node if the block is
-        empty). This allows for easy chaining.
+        empty). This allows chaining.
         """
 
         while 1:
+            # We might already have tokens from parsing a line to check if it's
+            # a property and discovering it isn't. This is a kind of "unget".
             if not self._has_tokens:
-                # Also advances to the next line
+                # Advance to the next line
                 if not self._next_line():
                     if end_token is not None:
                         raise KconfigSyntaxError("Unexpected end of file " +
@@ -987,9 +1288,8 @@ class Config(object):
                 continue
 
             if t0 in (_T_CONFIG, _T_MENUCONFIG):
-                # The tokenizer will automatically allocate a new Symbol object
-                # for any new names it encounters, so we don't need to worry
-                # about that here.
+                # The tokenizer allocates a Symbol objects the first time a
+                # symbol is seen
                 sym = self._next_token()
 
                 node = MenuNode()
@@ -1012,7 +1312,7 @@ class Config(object):
                 prev_node.next = prev_node = node
 
             elif t0 == _T_SOURCE:
-                self._enter_file(self._expand_sym_refs(self._next_token()))
+                self._enter_file(self._expand_syms(self._next_token()))
                 prev_node = self._parse_block(None,            # end_token
                                               parent,
                                               visible_if_deps,
@@ -1133,19 +1433,17 @@ class Config(object):
         """
         Parses properties for symbols, menus, choices, and comments. Also takes
         care of propagating dependencies from the menu node to the properties
-        of the item (this mirrors the inner working of the C tools).
+        of the item (this mirrors the C tools, though they do it after
+        parsing).
 
         node:
-          The menu node we're parsing properties on. Some properties (prompts,
-          help texts, 'depends on') apply to the Menu node, while the others
-          apply to the contained item.
+          The menu node we're parsing properties on. Prompt, help text,
+          'depends on', and 'visible if' properties apply to the Menu node,
+          while the others apply to the contained item.
 
         visible_if_deps:
           'visible if' dependencies from enclosing menus. Propagated to Symbol
           and Choice prompts.
-
-        Stops when finding a line that isn't part of the properties, and
-        returns a (line, tokens) tuple for it so it can be reused.
         """
 
         # New properties encountered at this location. A local 'depends on'
@@ -1157,12 +1455,12 @@ class Config(object):
         implies = []
         ranges = []
 
-        # Menu node dependency from 'depends on'. Will get propagated to the
+        # Menu node dependencies from 'depends on'. Will get propagated to the
         # properties above.
         node.dep = self.y
 
         while 1:
-            # Also advances to the next line
+            # Advance to the next line
             if not self._next_line():
                 break
 
@@ -1205,10 +1503,12 @@ class Config(object):
                 help_lines = [_deindent(line, indent).rstrip()]
                 while 1:
                     line = self._next_line_no_join()
+
                     if not line or \
                        (not line.isspace() and _indentation(line) < indent):
                         node.help = "\n".join(help_lines).rstrip() + "\n"
                         break
+
                     help_lines.append(_deindent(line, indent).rstrip())
 
                 if not line:
@@ -1229,7 +1529,7 @@ class Config(object):
                 implies.append((self._next_token(), self._parse_cond()))
 
             elif t0 in (_T_BOOL, _T_TRISTATE, _T_INT, _T_HEX, _T_STRING):
-                node.item._type = _TOKEN_TO_TYPE[t0]
+                node.item.orig_type = _TOKEN_TO_TYPE[t0]
 
                 if self._peek_token() is not None:
                     prompt = (self._next_token(), self._parse_cond())
@@ -1238,7 +1538,7 @@ class Config(object):
                 defaults.append((self._parse_expr(False), self._parse_cond()))
 
             elif t0 in (_T_DEF_BOOL, _T_DEF_TRISTATE):
-                node.item._type = _TOKEN_TO_TYPE[t0]
+                node.item.orig_type = _TOKEN_TO_TYPE[t0]
 
                 defaults.append((self._parse_expr(False), self._parse_cond()))
 
@@ -1288,13 +1588,13 @@ class Config(object):
                     # keep being called "MODULES".
                     if node.item is not self.modules:
                         self._warn("the 'modules' option is not supported. "
-                                   "Let me know if this is a problem for you; "
-                                   "it shouldn't be that hard to implement. "
-                                   "(Note that modules are still supported -- "
+                                   "Let me know if this is a problem for you, "
+                                   "as it wouldn't be that hard to implement. "
+                                   "Note that modules are supported -- "
                                    "Kconfiglib just assumes the symbol name "
                                    "MODULES, like older versions of the C "
                                    "implementation did when 'option modules' "
-                                   "wasn't used.)",
+                                   "wasn't used.",
                                    self._filename, self._linenr)
 
                 elif self._check_token(_T_ALLNOCONFIG_Y):
@@ -1322,6 +1622,7 @@ class Config(object):
 
             else:
                 self._tokens_i = -1
+                # Reuse the tokens for the non-property line later
                 self._has_tokens = True
                 break
 
@@ -1358,7 +1659,7 @@ class Config(object):
 
             # Handle selects
             for target, cond in selects:
-                # Only stored for convenience. Not used during evaluation.
+                # Only stored for inspection. Not used during evaluation.
                 node.item.selects.append(
                     (target, self._make_and(cond, node.dep)))
 
@@ -1371,7 +1672,7 @@ class Config(object):
 
             # Handle implies
             for target, cond in implies:
-                # Only stored for convenience. Not used during evaluation.
+                # Only stored for inspection. Not used during evaluation.
                 node.item.implies.append(
                     (target, self._make_and(cond, node.dep)))
 
@@ -1384,19 +1685,12 @@ class Config(object):
 
     def _parse_expr(self, transform_m):
         """
-        Parses an expression from the tokens in Config._tokens using a simple
-        top-down approach. The result has the form
-        '(<operator> <operand 1> <operand 2>)' where <operator> is e.g.
-        kconfiglib.AND. If there is only one operand (i.e., no && or ||), then
-        the operand is returned directly. This also goes for subexpressions.
-
-        As an example, A && B && (!C || D == 3) is represented as the tuple
-        structure (AND, A, (AND, B, (OR, (NOT, C), (EQUAL, D, 3)))), with the
-        Symbol objects stored directly in the expression.
+        Parses an expression from the tokens in Kconfig._tokens using a simple
+        top-down approach. See the module docs for the expression format.
 
         transform_m:
-          True if 'm' should be rewritten to 'm && MODULES'. See
-          the Config.eval_string() documentation.
+          True if m should be rewritten to m && MODULES. See the
+          Kconfig.eval_string() documentation.
         """
 
         # Grammar:
@@ -1453,8 +1747,7 @@ class Config(object):
                 # Plain symbol
 
                 # For conditional expressions ('depends on <expr>',
-                # '... if <expr>', etc.), "m" and m are rewritten to
-                # "m" && MODULES.
+                # '... if <expr>', etc.), m is rewritten to m && MODULES.
                 if transform_m and token is self.m:
                     return (AND, self.m, self.modules)
 
@@ -1477,52 +1770,78 @@ class Config(object):
         self._parse_error("malformed expression")
 
     #
-    # Symbol lookup
+    # Caching and invalidation
     #
 
-    def _lookup_sym(self, name):
+    def _build_dep(self):
         """
-        Fetches the symbol 'name' from the symbol table, creating and
-        registering it if it does not exist. TODO If 'for_eval_string' is True,
-        the symbol won't be added to the symbol table if it does not exist.
-        This is for Config.eval_string().
+        Populates the Symbol._direct_dependents sets, which link symbols to the
+        symbols that immediately depend on them in the sense that changing the
+        value of the symbol might affect the values of the dependent symbols.
+        This is used for caching/invalidation.
+
+        The calculated sets might be larger than necessary as we don't do any
+        complex analysis of the expressions.
         """
-        if name in self.syms:
-            return self.syms[name]
 
-        sym = Symbol()
-        sym.config = self
-        sym.name = name
-        sym.is_constant = False
-        sym.rev_dep = sym.weak_rev_dep = sym.direct_dep = self.n
+        # The directly dependent symbols of a symbol S are:
+        #
+        #  - Any symbols whose prompts, default values, rev_dep (select
+        #    condition), weak_rev_dep (imply condition), or ranges depend on S
+        #
+        #  - Any symbol that has S as a direct dependency (has S in
+        #    direct_dep). This is needed to get invalidation right for
+        #    'imply'.
+        #
+        #  - Any symbols that belong to the same choice statement as S. These
+        #    won't be included in S._direct_dependents as it creates dependency
+        #    loops, but S._get_dependent() includes them.
+        #
+        #  - Any symbols in a choice statement that depends on S
 
-        if self._parsing_kconfigs:
-            self.syms[name] = sym
-        else:
-            self._warn("no symbol {} in configuration".format(name))
+        # Only calculate _direct_dependents for defined symbols. Constant and
+        # undefined symbols could theoretically be selected/implied, but it
+        # shouldn't change their value, so it's not a true dependency.
+        for sym in self.defined_syms:
+            for node in sym.nodes:
+                if node.prompt is not None:
+                    _make_depend_on(sym, node.prompt[1])
 
-        return sym
+            for value, cond in sym.defaults:
+                _make_depend_on(sym, value)
+                _make_depend_on(sym, cond)
 
-    def _lookup_const_sym(self, name):
-        """
-        TODO: say something
-        """
-        if name in self.const_syms:
-            return self.const_syms[name]
+            _make_depend_on(sym, sym.rev_dep)
+            _make_depend_on(sym, sym.weak_rev_dep)
 
-        sym = Symbol()
-        sym.config = self
-        sym.name = name
-        sym.is_constant = True
-        sym.rev_dep = sym.weak_rev_dep = sym.direct_dep = self.n
+            for low, high, cond in sym.ranges:
+                _make_depend_on(sym, low)
+                _make_depend_on(sym, high)
+                _make_depend_on(sym, cond)
 
-        if self._parsing_kconfigs:
-            self.const_syms[name] = sym
+            _make_depend_on(sym, sym.direct_dep)
+
+            if sym.choice is not None:
+                for node in sym.choice.nodes:
+                    if node.prompt is not None:
+                        _make_depend_on(sym, node.prompt[1])
+
+                for _, cond in sym.choice.defaults:
+                    _make_depend_on(sym, cond)
+
+    def _invalidate_all(self):
+        # Undefined symbols never change value and don't need to be
+        # invalidated, so we can just iterate over defined symbols.
+        # Invalidating constant symbols would break things horribly.
+        for sym in self.defined_syms:
+            sym._invalidate()
+
+        for choice in self._choices:
+            choice._invalidate()
 
-        return sym
 
     #
-    # .config generation
+    # .config writing
     #
 
     def _get_config_strings(self):
@@ -1535,7 +1854,7 @@ class Config(object):
         # .config entry. We reset it prior to writing out a new .config. It
         # only needs to be reset for defined symbols, because undefined symbols
         # will never be written out (because they do not appear structure
-        # rooted at Config.top_node).
+        # rooted at Kconfig.top_node).
         #
         # The C tools reuse _write_to_conf for this, but we cache
         # _write_to_conf together with the value and don't invalidate cached
@@ -1549,6 +1868,7 @@ class Config(object):
             return []
 
         config_strings = []
+        # Small optimization
         add_fn = config_strings.append
 
         while 1:
@@ -1581,82 +1901,12 @@ class Config(object):
                 else:
                     return config_strings
 
-    #
-    # Dependency tracking (for caching and invalidation)
-    #
-
-    def _build_dep(self):
-        """
-        Populates the Symbol._direct_dependents sets, which link symbols to the
-        symbols that immediately depend on them in the sense that changing the
-        value of the symbol might affect the values of the dependent symbols.
-        This is used for caching/invalidation purposes.
-
-        The calculated sets might be larger than necessary as we don't do any
-        complex analysis of the expressions.
-        """
-
-        # The directly dependent symbols of a symbol S are:
-        #
-        #  - Any symbols whose prompts, default values, rev_dep (select
-        #    condition), weak_rev_dep (imply condition), or ranges depend on S
-        #
-        #  - Any symbol that has S as a direct dependency (has S in
-        #    direct_dep). This is needed to get invalidation right for
-        #    'imply'.
-        #
-        #  - Any symbols that belong to the same choice statement as S. These
-        #    won't be included in S._direct_dependents as it creates dependency
-        #    loops, but S._get_dependent() includes them.
-        #
-        #  - Any symbols in a choice statement that depends on S
-
-        # Only calculate _direct_dependents for defined symbols. Undefined
-        # symbols could theoretically be selected/implied, but it wouldn't
-        # change their value (they always evaluate to their name), so it's not
-        # a true dependency.
-
-        for sym in self.defined_syms:
-            for node in sym.nodes:
-                if node.prompt is not None:
-                    _make_depend_on(sym, node.prompt[1])
-
-            for value, cond in sym.defaults:
-                _make_depend_on(sym, value)
-                _make_depend_on(sym, cond)
-
-            _make_depend_on(sym, sym.rev_dep)
-            _make_depend_on(sym, sym.weak_rev_dep)
-
-            for low, high, cond in sym.ranges:
-                _make_depend_on(sym, low)
-                _make_depend_on(sym, high)
-                _make_depend_on(sym, cond)
-
-            _make_depend_on(sym, sym.direct_dep)
-
-            if sym.choice is not None:
-                for node in sym.choice.nodes:
-                    if node.prompt is not None:
-                        _make_depend_on(sym, node.prompt[1])
-
-                for _, cond in sym.choice.defaults:
-                    _make_depend_on(sym, cond)
-
-    def _invalidate_all(self):
-        # Undefined symbols never change value and don't need to be
-        # invalidated, so we can just iterate over defined symbols
-        for sym in self.defined_syms:
-            sym._invalidate()
-
-        for choice in self._choices:
-            choice._invalidate()
 
     #
-    # Printing and misc.
+    # Misc.
     #
 
-    def _expand_sym_refs(self, s):
+    def _expand_syms(self, s):
         """
         Expands $-references to symbols in 's' to symbol values, or to the
         empty string for undefined symbols.
@@ -1673,44 +1923,6 @@ class Config(object):
                 (sym.str_value if sym is not None else "") + \
                 s[sym_ref_match.end():]
 
-    #
-    # Expression construction
-    #
-
-    def _make_and(self, e1, e2):
-        """
-        Constructs an AND (&&) expression. Performs trivial simplification.
-        """
-        if e1 is self.y:
-            return e2
-
-        if e2 is self.y:
-            return e1
-
-        if e1 is self.n or e2 is self.n:
-            return self.n
-
-        return (AND, e1, e2)
-
-    def _make_or(self, e1, e2):
-        """
-        Constructs an OR (||) expression. Performs trivial simplification.
-        """
-        if e1 is self.n:
-            return e2
-
-        if e2 is self.n:
-            return e1
-
-        if e1 is self.y or e2 is self.y:
-            return self.y
-
-        return (OR, e1, e2)
-
-    #
-    # Errors and warnings
-    #
-
     def _parse_error(self, msg):
         if self._filename is None:
             loc = ""
@@ -1740,6 +1952,7 @@ class Config(object):
             'attempt to assign the value "{}" to the undefined symbol {}' \
             .format(val, name), filename, linenr)
 
+
 class Symbol(object):
     """
     Represents a configuration symbol:
@@ -1747,151 +1960,159 @@ class Symbol(object):
       (menu)config FOO
           ...
 
-    The following attributes are available on Symbol instances. They should be
-    viewed as read-only, and some are implemented through @property magic (but
-    are still efficient to access due to internal caching).
+    The following attributes are available. They should be viewed as read-only,
+    and some are implemented through @property magic (but are still efficient
+    to access due to internal caching).
 
-    (Note: Prompts and help texts are stored in the Symbol's MenuNode(s) rather
-    than the Symbol itself. This matches the C tools.)
+    Note: Prompts and help texts are stored in the Symbol's MenuNode(s) rather
+    than the Symbol itself. Check the 'nodes' attribute. This matches the C
+    tools.
 
     name:
       The name of the symbol, e.g. "FOO" for 'config FOO'.
 
     type:
       The type of the symbol. One of BOOL, TRISTATE, STRING, INT, HEX, UNKNOWN.
-      UNKNOWN is for undefined symbols and symbols defined without a type.
+      UNKNOWN is for undefined symbols, (non-special) constant symbols, and
+      symbols defined without a type.
 
-      When running without modules (CONFIG_MODULES=n), TRISTATE symbols
-      magically change type to BOOL. This also happens for symbols within
-      choices in "y" mode. This matches the C tools, and makes sense for
-      menuconfig-like functionality. (Check the implementation of the property
-      if you need to get the original type.)
+      When running without modules (MODULES having the value n), TRISTATE
+      symbols magically change type to BOOL. This also happens for symbols
+      within choices in "y" mode. This matches the C tools, and makes sense for
+      menuconfig-like functionality.
+
+    orig_type:
+      The type as given in the Kconfig file, without any magic applied. Used
+      when printing the symbol.
 
     str_value:
-      TODO
-      The current value of the symbol. Automatically recalculated as
-      dependencies change.
+      The value of the symbol as a string. Gives the string value for
+      string/int/hex symbols. For bool/tristate symbols, gives "n", "m", or
+      "y".
+
+      This is the symbol value that's used in relational expressions
+      (A = B, A != B, etc.)
 
     tri_value:
-      TODO
+      The tristate value of the symbol as an integer. One of 0, 1, 2,
+      representing n, m, y. Always 0 (n) for non-bool/tristate symbols.
+
+      This is the symbol value that's used outside of relation expressions
+      (A, !A, A && B, A || B).
 
     assignable:
-       A string containing the tristate values that can be assigned to the
-       symbol, ordered from lowest (n) to highest (y). This corresponds to the
-       selections available in the 'menuconfig' interface. The assignable
-       values are calculated from the Symbol's visibility and selects/implies.
+      A tuple containing the tristate user values that can currently be
+      assigned to the symbol (that will be respected), ordered from lowest (0,
+      representing n) to highest (2, representing y). This corresponds to the
+      selections available in the menuconfig interface. The set of assignable
+      values is calculated from the symbol's visibility and selects/implies.
 
-       Returns the empty string for non-BOOL/TRISTATE and symbols with
-       visibility "n". The other possible values are "ny", "nmy", "my", "m",
-       and "y". A "m" or "y" result means the symbol is visible but "locked" to
-       that particular value (through a select, perhaps in combination with a
-       prompt dependency). menuconfig seems to represent this as -M- and -*-,
-       respectively.
+      Returns the empty set for non-bool/tristate symbols and for symbols with
+      visibility n. The other possible values are (0, 2), (0, 1, 2), (1, 2),
+      (1,), and (2,). A (1,) or (2,) result means the symbol is visible but
+      "locked" to that particular tristate value (through a select, perhaps in
+      combination with a prompt condition). menuconfig represents this as -M-
+      and -*-, respectively.
 
-       Some handy 'assignable' idioms:
+      For string/hex/int symbols, check if Symbol.visibility is non-0 (non-n)
+      instead to determine if the value can be changed.
 
-         # Is the symbol assignable (visible)?
-         if sym.assignable:
-             # What's the highest value it can be assigned? [-1] in Python
-             # gives the last element.
-             sym_high = sym.assignable[-1]
+      Some handy 'assignable' idioms:
 
-             # The lowest?
-             sym_low = sym.assignable[0]
+        # Is the symbol assignable (visible)?
+        if sym.assignable:
+            # What's the highest value it can be assigned? [-1] in Python
+            # gives the last element.
+            sym_high = sym.assignable[-1]
 
-         # Can the symbol be assigned the value "m"?
-         if "m" in sym.assignable:
-             ...
+            # The lowest?
+            sym_low = sym.assignable[0]
 
-    visibility:
-      The visibility of the symbol's prompt(s): one of "n", "m", or "y". This
-      acts as an upper bound on the values the user can set for the symbol (via
-      Symbol.set_value() or a .config file). User values higher than the
-      visibility are truncated down to the visibility.
+            # Can the symbol be set to at least m?
+            if sym.assignable[-1] >= 1:
+                ...
 
-      If the visibility is "n", the user value is ignored, and the symbol is
-      not visible in e.g. the menuconfig interface. The visibility of symbols
-      without prompts is always "n". Symbols with "n" visibility can only get a
-      non-"n" value through a default, select, or imply.
+        # Can the symbol be set to m?
+        if 1 in sym.assignable:
+            ...
 
-      Note that 'depends on' and parent dependencies (including 'visible if'
-      dependencies) are propagated to the prompt dependencies. Additional
-      dependencies can be specified with e.g. 'bool "foo" if <cond>".
+    visibility:
+      The visibility of the symbol. One of 0, 1, 2, representing n, m, y. See
+      the module documentation for an overview of symbol values and visibility.
 
     user_str_value:
-      The string value assigned with Symbol.set_value(), or None if no value
-      has been assigned. This won't necessarily match 'str_value' even if set,
-      as dependencies and prompt visibility take precedence.
+      The user value of the symbol as a string, or None if no user value has
+      been assigned (via Kconfig.load_value() or Symbol.set_value()). See
+      str_value.
 
-      Note that you should use Symbol.set_value() to change this value (which
-      will also change user_tri_value). Changing the value directly will break
-      things, as Kconfiglib might need to invalidate other symbols. Properties
-      are always read-only.
-
-      The string value is only used in comparisons (e.g.
-      'depends on SYMBOL = "foo"'). See user_tri_value.
+      Warning: Do not assign directly to this. It will break things. Use
+      Symbol.set_value().
 
     user_tri_value:
-      The tristate value corresponding to user_str_value. The rule is that "n",
-      "m", and "y" correspond to 0, 1, and 2 for BOOL and TRISTATE symbols.
-      Other symbol types always evaluate to 0 (n) in a tristate sense.
+      The user value of the symbol as a tristate value (0, 1, 2), or None if no
+      user value has been assigned (via Kconfig.load_value() or
+      Symbol.set_value()). See tri_value.
+
+      Always 0 (n) for non-bool/tristate symbols (or None if no user value has
+      been set).
+
+      Warning: Do not assign directly to this. It will break things. Use
+      Symbol.set_value().
 
     config_string:
       The .config assignment string that would get written out for the symbol
-      by Config.write_config(). None if no .config assignment would get written
-      out. In general, visible symbols, symbols with (active) defaults, and
-      selected symbols get written out.
+      by Kconfig.write_config(). None if no .config assignment would get
+      written out. In general, visible symbols, symbols with (active) defaults,
+      and selected symbols get written out.
 
     nodes:
-      A list of MenuNode's for this symbol. For most symbols, this list will
-      contain a single MenuNode. Undefined symbols get an empty list, and
-      symbols defined in multiple locations get one node for each location.
+      A list of MenuNodes for this symbol. Will contain a single MenuNode for
+      most symbols. Undefined and constant symbols have an empty nodes list.
+      Symbols defined in multiple locations get one node for each location.
 
     choice:
       Holds the parent Choice for choice symbols, and None for non-choice
       symbols. Doubles as a flag for whether a symbol is a choice symbol.
 
     defaults:
-      List of (default, cond) tuples for the symbol's 'default's. For example,
-      'default A && B if C || D' is represented as ((AND, A, B), (OR, C, D)).
-      If no condition was given, 'cond' is self.config.y.
+      List of (default, cond) tuples for the symbol's 'default' properties. For
+      example, 'default A && B if C || D' is represented as
+      ((AND, A, B), (OR, C, D)). If no condition was given, 'cond' is
+      self.config.y.
 
       Note that 'depends on' and parent dependencies are propagated to
       'default' conditions.
 
     selects:
-      List of (symbol, cond) tuples for the symbol's 'select's. For example,
-      'select A if B' is represented as (A, B). If no condition was given,
-      'cond' is self.config.y.
+      List of (symbol, cond) tuples for the symbol's 'select' properties. For
+      example, 'select A if B' is represented as (A, B). If no condition was
+      given, 'cond' is self.config.y.
 
       Note that 'depends on' and parent dependencies are propagated to 'select'
       conditions.
 
     implies:
-      List of (symbol, cond) tuples for the symbol's 'imply's. For example,
-      'imply A if B' is represented as (A, B). If no condition was given,
-      'cond' is self.config.y.
-
-      Note that 'depends on' and parent dependencies are propagated to 'imply'
-      conditions.
+      Same format as 'selects', for imply.
 
     ranges:
-      List of (low, high, cond) tuples for the symbol's 'range's. For example,
-      'range 1 2 if A' is represented as (1, 2, A). If there is no condition,
-      'cond' is self.config.y.
+      List of (low, high, cond) tuples for the symbol's 'range' properties. For
+      example, 'range 1 2 if A' is represented as (1, 2, A). If there is no
+      condition, 'cond' is self.config.y.
 
       Note that 'depends on' and parent dependencies are propagated to 'range'
       conditions.
 
-      Gotcha: Integers are represented as Symbols too. Undefined symbols get
-      their name as their value, so this works out. The C tools work the same
-      way.
+      Gotcha: 1 and 2 above will be represented as (undefined) Symbols rather
+      than plain integers. Undefined symbols get their name as their string
+      value, so this works out. The C tools work the same way.
 
     rev_dep:
-      Reverse dependency expression from being 'select'ed by other symbols.
+      Reverse dependency expression from other symbols selecting this symbol.
       Multiple selections get ORed together. A condition on a select is ANDed
-      with the selecting symbol. For example, if A has 'select FOO' and B has
-      'select FOO if C', then FOO's rev_dep will be '(OR, A, (AND, B, C))'.
+      with the selecting symbol.
+
+      For example, if A has 'select FOO' and B has 'select FOO if C', then
+      FOO's rev_dep will be (OR, A, (AND, B, C)).
 
     weak_rev_dep:
       Like rev_dep, for imply.
@@ -1899,6 +2120,8 @@ class Symbol(object):
     direct_dep:
       The 'depends on' dependencies. If a symbol is defined in multiple
       locations, the dependencies at each location are ORed together.
+      Internally, this is only used to implement 'imply', which only applies if
+      the implied symbol has expr_value(self.direct_dep) != 0.
 
     env_var:
       If the Symbol has an 'option env="FOO"' option, this contains the name
@@ -1908,18 +2131,23 @@ class Symbol(object):
       'option env="FOO"' acts as a 'default' property whose value is the value
       of $FOO.
 
-      env_var is also set (to "<uname release>") on the predefined symbol
+      env_var is set to "<uname release>" for the predefined symbol
       UNAME_RELEASE, which holds the 'release' field from uname.
 
       Symbols with an 'option env' option are never written out to .config
-      files.
+      files, even if they are visible. env_var corresponds to a flag called
+      SYMBOL_AUTO in the C implementation.
 
     is_allnoconfig_y:
       True if the symbol has 'option allnoconfig_y' set on it. This has no
-      effect internally, but can be checked by scripts.
+      effect internally (except when printing symbols), but can be checked by
+      scripts.
+
+    is_constant:
+      True if the symbol is a constant (quoted) symbol.
 
     config:
-      The Config instance this symbol is from.
+      The Kconfig instance this symbol is from.
     """
 
     __slots__ = (
@@ -1930,7 +2158,6 @@ class Symbol(object):
         "_cached_tri_val",
         "_cached_vis",
         "_direct_dependents",
-        "_type",
         "_write_to_conf",
         "choice",
         "config",
@@ -1942,6 +2169,7 @@ class Symbol(object):
         "is_constant",
         "name",
         "nodes",
+        "orig_type",
         "ranges",
         "rev_dep",
         "selects",
@@ -1960,11 +2188,12 @@ class Symbol(object):
         See the class documentation.
         """
 
-        if self._type == TRISTATE and \
+        if self.orig_type == TRISTATE and \
            ((self.choice is not None and self.choice.tri_value == 2) or
             not self.config.modules.tri_value):
             return BOOL
-        return self._type
+
+        return self.orig_type
 
     @property
     def str_value(self):
@@ -1975,14 +2204,14 @@ class Symbol(object):
         if self._cached_str_val is not None:
             return self._cached_str_val
 
-        if self._type in (BOOL, TRISTATE):
+        if self.orig_type in (BOOL, TRISTATE):
             self._cached_str_val = TRI_TO_STR[self.tri_value]
             return self._cached_str_val
 
         # As a quirk of Kconfig, undefined symbols get their name as their
         # string value. This is why things like "FOO = bar" work for seeing if
         # FOO has the value "bar".
-        if self._type == UNKNOWN:
+        if self.orig_type == UNKNOWN:
             self._cached_str_val = self.name
             return self.name
 
@@ -1991,8 +2220,8 @@ class Symbol(object):
 
         self._write_to_conf = (vis != 0)
 
-        if self._type in (INT, HEX):
-            base = _TYPE_TO_BASE[self._type]
+        if self.orig_type in (INT, HEX):
+            base = _TYPE_TO_BASE[self.orig_type]
 
             # Check if a range is in effect
             for low_expr, high_expr, cond in self.ranges:
@@ -2044,7 +2273,7 @@ class Symbol(object):
 
                                 if clamped_val is not None:
                                     val = (hex(clamped_val)
-                                           if self._type == HEX else
+                                           if self.orig_type == HEX else
                                            str(clamped_val))
 
                             break
@@ -2054,12 +2283,14 @@ class Symbol(object):
                     # constraint, then the low end of the range is used,
                     # provided it's > 0, with "0x" prepended as appropriate.
                     if has_active_range and low > 0:
-                        val = (hex(low) if self._type == HEX else str(low))
+                        val = (hex(low) if self.orig_type == HEX else str(low))
 
-        elif self._type == STRING:
+        elif self.orig_type == STRING:
             if vis and self.user_str_value is not None:
+                # If the symbol is visible and has a user value, use that
                 val = self.user_str_value
             else:
+                # Otherwise, look at defaults
                 for val_expr, cond in self.defaults:
                     if expr_value(cond):
                         self._write_to_conf = True
@@ -2078,7 +2309,7 @@ class Symbol(object):
         if self._cached_tri_val is not None:
             return self._cached_tri_val
 
-        if self._type not in (BOOL, TRISTATE):
+        if self.orig_type not in (BOOL, TRISTATE):
             self._cached_tri_val = 0
             return self._cached_tri_val
 
@@ -2089,11 +2320,11 @@ class Symbol(object):
             self._write_to_conf = (vis != 0)
 
             if vis and self.user_tri_value is not None:
-                # If the symbol is visible and has a user value, we use that
+                # If the symbol is visible and has a user value, use that
                 val = min(self.user_tri_value, vis)
 
             else:
-                # Otherwise, we look at defaults and weak reverse dependencies
+                # Otherwise, look at defaults and weak reverse dependencies
                 # (implies)
 
                 for default, cond in self.defaults:
@@ -2136,9 +2367,8 @@ class Symbol(object):
                         # mode == 1, user value available and not 0
                         val = 1
 
-        # m is promoted to y in two circumstances:
-        #  1) If our type is boolean
-        #  2) If our weak_rev_dep (from IMPLY) is y
+        # m is promoted to y for (1) bool symbols and (2) symbols with a
+        # weak_rev_dep (from imply) of y
         if val == 1 and \
            (self.type == BOOL or expr_value(self.weak_rev_dep) == 2):
             val = 2
@@ -2175,8 +2405,7 @@ class Symbol(object):
         """
 
         if self.env_var is not None:
-            # Variables with 'option env' never get written out. This
-            # corresponds to the SYMBOL_AUTO flag in the C implementation.
+            # Corresponds to SYMBOL_AUTO being set in the C implementation
             return None
 
         # Note: _write_to_conf is determined when the value is calculated. This
@@ -2185,44 +2414,51 @@ class Symbol(object):
         if not self._write_to_conf:
             return None
 
-        if self._type in (BOOL, TRISTATE):
+        if self.orig_type in (BOOL, TRISTATE):
             return "{}{}={}\n" \
                    .format(self.config.config_prefix, self.name, val) \
                    if val != "n" else \
                    "# {}{} is not set\n" \
                    .format(self.config.config_prefix, self.name)
 
-        if self._type in (INT, HEX):
+        if self.orig_type in (INT, HEX):
             return "{}{}={}\n" \
                    .format(self.config.config_prefix, self.name, val)
 
-        if self._type == STRING:
+        if self.orig_type == STRING:
             # Escape \ and "
             return '{}{}="{}"\n' \
-                   .format(self.config.config_prefix, self.name,
-                           val.replace("\\", "\\\\").replace('"', '\\"'))
+                   .format(self.config.config_prefix, self.name, escape(val))
 
         _internal_error("Internal error while creating .config: unknown "
-                        'type "{}".'.format(self._type))
+                        'type "{}".'.format(self.orig_type))
 
     def set_value(self, value):
         """
         Sets the user value of the symbol.
 
         Equal in effect to assigning the value to the symbol within a .config
-        file. Use the 'assignable' attribute to check which values can
-        currently be assigned. Setting values outside 'assignable' will cause
-        Symbol.user_str/tri_value to differ from Symbol.str/tri_value (be
-        truncated down or up). Values that are invalid for the type (such as
-        "foo" or "m" for a BOOL) are ignored (and won't be stored in
-        Symbol.user_str/tri_value). A warning is printed for attempts to assign
-        invalid values.
+        file. For bool and tristate symbols, use the 'assignable' attribute to
+        check which values can currently be assigned. Setting values outside
+        'assignable' will cause Symbol.user_str/tri_value to differ from
+        Symbol.str/tri_value (be truncated down or up). Values that are invalid
+        for the type (such as "foo" or "m" for a BOOL) are ignored and won't be
+        stored in Symbol.user_str/tri_value (Kconfiglib will print a warning by
+        default).
 
-        The values of other symbols that depend on this symbol are
-        automatically recalculated to reflect the new value.
+        Other symbols that depend (possibly indirectly) on this symbol are
+        automatically recalculated to reflect the assigned value.
 
         value:
           The user value to give to the symbol.
+
+          A a convenience, set_value() accepts both 0/1/2 (plain python
+          integers) and "n"/"m"/"y" as the the format of the 'value' argument
+          for bool and tristate symbols. This was added so that 'assignable'
+          could return integers (which are easier to work with) while at the
+          same time being able to assign a value from 'assignable' without an
+          ugly conversion. Accepting strings for all symbols streamlines
+          .config handling.
         """
         self._set_value_no_invalidate(value, False)
 
@@ -2235,7 +2471,7 @@ class Symbol(object):
     def unset_value(self):
         """
         Resets the user value of the symbol, as if the symbol had never gotten
-        a user value via Config.load_config() or Symbol.set_value().
+        a user value via Kconfig.load_config() or Symbol.set_value().
         """
         self.user_str_value = self.user_tri_value = None
         self._rec_invalidate()
@@ -2328,7 +2564,7 @@ class Symbol(object):
         #   rev_dep
         #   weak_rev_dep
 
-        self._type = UNKNOWN
+        self.orig_type = UNKNOWN
         self.defaults = []
         self.selects = []
         self.implies = []
@@ -2338,7 +2574,7 @@ class Symbol(object):
 
         self.user_str_value = self.user_tri_value = None
 
-        # Populated in Config._build_dep() after parsing. Links the symbol to
+        # Populated in Kconfig._build_dep() after parsing. Links the symbol to
         # the symbols that immediately depend on it (in a caching/invalidation
         # sense). The total set of dependent symbols for the symbol is
         # calculated as needed in _get_dependent().
@@ -2364,42 +2600,42 @@ class Symbol(object):
         Worker function for the 'assignable' attribute.
         """
 
-        if self._type not in (BOOL, TRISTATE):
-            return ""
+        if self.orig_type not in (BOOL, TRISTATE):
+            return ()
 
         vis = self.visibility
 
         if not vis:
-            return ""
+            return ()
 
         rev_dep_val = expr_value(self.rev_dep)
 
         if vis == 2:
             if not rev_dep_val:
                 if self.type == BOOL or expr_value(self.weak_rev_dep) == 2:
-                    return "ny"
-                return "nmy"
+                    return (0, 2)
+                return (0, 1, 2)
 
             if rev_dep_val == 2:
-                return "y"
+                return (2,)
 
             # rev_dep_val == 1
 
             if self.type == BOOL or expr_value(self.weak_rev_dep) == 2:
-                return "y"
-            return "my"
+                return (2,)
+            return (1, 2)
 
         # vis == 1
 
         if not rev_dep_val:
-            return "m" if expr_value(self.weak_rev_dep) != 2 else "y"
+            return (1,) if expr_value(self.weak_rev_dep) != 2 else (2,)
 
         if rev_dep_val == 2:
-            return "y"
+            return (2,)
 
         # vis == rev_dep_val == 1
 
-        return "m"
+        return (1,)
 
     def _set_value_no_invalidate(self, value, suppress_prompt_warning):
         """
@@ -2412,14 +2648,23 @@ class Symbol(object):
         """
 
         # Check if the value is valid for our type
-        if not ((self._type == BOOL     and value in ("n", "y")     ) or
-                (self._type == TRISTATE and value in ("n", "m", "y")) or
-                (self._type == STRING                               ) or
-                (self._type == INT      and _is_base_n(value, 10)   ) or
-                (self._type == HEX      and _is_base_n(value, 16)   )):
-            self.config._warn('the value "{}" is invalid for {}, which has '
-                              "type {}. Assignment ignored."
-                              .format(value, self.name, _TYPENAME[self._type]))
+        if not ((self.orig_type == BOOL     and value in (0, 2)       ) or
+                (self.orig_type == TRISTATE and value in (0, 1, 2)    ) or
+                (self.orig_type == STRING   and isinstance(value, str)) or
+                (self.orig_type == INT      and isinstance(value, str)
+                                            and _is_base_n(value, 10) ) or
+                (self.orig_type == HEX      and isinstance(value, str)
+                                            and _is_base_n(value, 16))):
+
+            warning = "the value '{}' is invalid for {}, which has type {}" \
+                      .format(value, self.name, _TYPENAME[self.orig_type])
+
+            if self.orig_type in (BOOL, TRISTATE) and \
+               value in ("n", "m", "y"):
+                warning += ' (pass 0, 1, 2 for n, m, y, respectively)'
+
+            self.config._warn(warning)
+
             return
 
         if not self.nodes:
@@ -2436,11 +2681,12 @@ class Symbol(object):
                                   "promptless symbol {} will have no effect"
                                   .format(value, self.name))
 
-        self.user_str_value = value
-        self.user_tri_value = \
-            STR_TO_TRI[value] \
-            if self._type in (BOOL, TRISTATE) else \
-            0
+        if self.orig_type in (BOOL, TRISTATE):
+            self.user_str_value = TRI_TO_STR[value]
+            self.user_tri_value = value
+        else:
+            self.user_str_value = value
+            self.user_tri_value = 0
 
         # TODO: assigning automatically changes choice yada yada
 
@@ -2524,9 +2770,10 @@ class Choice(object):
 
       choice
           ...
+      endchoice
 
     The following attributes are available on Choice instances. They should be
-    viewed as read-only, and some are implemented through @property magic (but
+    treated as read-only, and some are implemented through @property magic (but
     are still efficient to access due to internal caching).
 
     name:
@@ -2542,29 +2789,40 @@ class Choice(object):
 
       When running without modules (CONFIG_MODULES=n), TRISTATE choices
       magically change type to BOOL. This matches the C tools, and makes sense
-      for menuconfig-like functionality. (Check the implementation of the
-      property if you need to get the original type.)
+      for menuconfig-like functionality.
+
+    orig_type:
+      The type as given in the Kconfig file, without any magic applied. Used
+      when printing the choice.
 
-    value:
+    tri_value:
       The tristate value (mode) of the choice. A choice can be in one of three
       modes:
 
-        "n" - The choice is not visible and no symbols can be selected.
+        0 (n) - The choice is disabled and no symbols can be selected. This
+                mode is only possible for choices with the 'optional' flag set
+                (see kconfig-language.txt).
 
-        "m" - Any number of symbols can be set to "m". The rest will be "n".
+        1 (m) - Any number of choice symbols can be set to "m", the rest will
+                be "n".
 
-        "y" - One symbol will be "y" while the rest are "n".
+        2 (y) - One symbol will be "y", the rest "n".
 
-      Only tristate choices can be in "m" mode, and the visibility of the
-      choice is an upper bound on the mode.
+      Only tristate choices can be in "m" mode. The visibility of the choice is
+      an upper bound on the mode.
 
       The mode changes automatically when a value is assigned to a symbol
       within the choice (this makes .config loading "just work"), and can also
       be changed via Choice.set_value().
 
-      See the implementation note at the end for one reason why it makes sense
-      to call this 'value' rather than e.g. 'mode'. It also makes the Choice
-      and Symbol interfaces consistent.
+      Implementation note: The C tools internally represent choices as a type
+      of symbol, with special-casing in many code paths. This is why there is a
+      lot of similarity to Symbol. The value (mode) of a choice is really just
+      a normal symbol value, and an implicit reverse dependency forces its
+      lower bound to 'm' for non-optional choices. Kconfiglib uses a separate
+      Choice class only because it makes the code and interface less confusing
+      (especially in a user-facing interface). Corresponding attributes have
+      the same name in the Symbol and Choice classes, for consistency.
 
     assignable:
       See the symbol class documentation. Gives the assignable values (modes).
@@ -2577,17 +2835,27 @@ class Choice(object):
       has no selected symbol (due to unsatisfied dependencies on choice
       symbols).
 
+      Warning: Do not assign directly to this. It will break things. Call
+      sym.set_value(2) on the choice symbol you want to select instead.
+
     default_selection:
       The symbol that would be selected by default, had the user not selected
       any symbol. Can be None for the same reasons as 'selected'.
 
-    user_str_value: TODO
-      The value (mode) selected by the user (by assigning some choice symbol or
-      calling Choice.set_value()). This does not necessarily match Choice.value
-      for the same reasons that Symbol.user_str_value might not match
-      Symbol.value.
+    user_str_value:
+      The value (mode) selected by the user (through Choice.set_value() or by
+      assigning a value to a symbol within the choice), represented as a
+      string. See Symbol.user_str_value.
+
+      Warning: Do not assign directly to this. It will break things. Use
+      Choice.set_value() or Symbol.set_value() instead.
+
+    user_tri_value:
+      The same value as user_str_value as a tristate (0, 1, 2). See
+      Symbol.user_tri_value.
 
-    user_tri_value: TODO
+      Warning: Do not assign directly to this. It will break things. Use
+      Choice.set_value() or Symbol.set_value() instead.
 
     user_selection:
       The symbol selected by the user (by setting it to "y"). Ignored if the
@@ -2597,9 +2865,11 @@ class Choice(object):
     syms:
       List of symbols contained in the choice.
 
-      Gotcha: If a symbol depends on a previous symbol within a choice so that
-      an implicit menu is created, it won't be a choice symbol, and won't be
-      included in 'syms'. There are real-world examples of this.
+      Gotcha: If a symbol depends on the previous symbol within a choice so
+      that an implicit menu is created, it won't be a choice symbol, and won't
+      be included in 'syms'. There are real-world examples of this, and it was
+      a PITA in older versions of Kconfiglib that didn't implement the menu
+      structure.
 
     nodes:
       A list of MenuNode's for this symbol. In practice, the list will probably
@@ -2607,35 +2877,28 @@ class Choice(object):
       in multiple locations by giving it a name, which adds more nodes.
 
     defaults:
-      List of (symbol, cond) tuples for the choices 'defaults's. For example,
-      'default A if B && C' is represented as (A, (AND, B, C)). If there is no
-      condition, 'cond' is self.config.y.
+      List of (symbol, cond) tuples for the choice's 'defaults' properties. For
+      example, 'default A if B && C' is represented as (A, (AND, B, C)). If
+      there is no condition, 'cond' is self.config.y.
 
       Note that 'depends on' and parent dependencies are propagated to
       'default' conditions.
 
     is_optional:
-      True if the choice has the 'optional' flag set on it.
-
-    Implementation note: The C tools internally represent choices as a type of
-    symbol, with special-casing in many code paths, which is why there is a lot
-    of similarity to Symbol above. The value (mode) is really just a normal
-    symbol value, and an implicit reverse dependency forces its lower bound to
-    'm' for non-optional choices. Kconfiglib uses a separate Choice class only
-    because it makes the code and interface less confusing (especially in a
-    user-facing interface).
+      True if the choice has the 'optional' flag set on it and can be in
+      n mode.
     """
 
     __slots__ = (
         "_cached_assignable",
         "_cached_selection",
         "_cached_vis",
-        "_type",
         "config",
         "defaults",
         "is_optional",
         "name",
         "nodes",
+        "orig_type",
         "syms",
         "user_selection",
         "user_str_value",
@@ -2648,10 +2911,13 @@ class Choice(object):
 
     @property
     def type(self):
-        """Returns the type of the choice. See Symbol.type."""
-        if self._type == TRISTATE and not self.config.modules.tri_value:
+        """
+        Returns the type of the choice. See Symbol.type.
+        """
+        if self.orig_type == TRISTATE and not self.config.modules.tri_value:
             return BOOL
-        return self._type
+
+        return self.orig_type
 
     @property
     def str_value(self):
@@ -2745,14 +3011,15 @@ class Choice(object):
         attribute (is_optional) can never be in "n" mode, but "n" is still
         accepted (and ignored) since it's not a malformed value.
         """
-        if not ((self._type == BOOL     and value in ("n", "y")    ) or
-                (self._type == TRISTATE and value in ("n", "m", "y"))):
-            self.config._warn('the value "{}" is invalid for the choice, '
+        if not ((self.orig_type == BOOL     and value in (0, 2)    ) or
+                (self.orig_type == TRISTATE and value in (0, 1, 2))):
+            self.config._warn("the value '{}' is invalid for the choice, "
                               "which has type {}. Assignment ignored"
-                              .format(value, _TYPENAME[self._type]))
+                              .format(value, _TYPENAME[self.orig_type]))
+            return
 
-        self.user_str_value = value
-        self.user_tri_value = STR_TO_TRI[value]
+        self.user_str_value = TRI_TO_STR[value]
+        self.user_tri_value = value
 
         if self.syms:
             # Hackish way to invalidate the choice and all the choice symbols
@@ -2831,7 +3098,7 @@ class Choice(object):
         #   config
 
         self.name = None
-        self._type = UNKNOWN
+        self.orig_type = UNKNOWN
         self.syms = []
         self.defaults = []
 
@@ -2857,16 +3124,16 @@ class Choice(object):
         vis = self.visibility
 
         if not vis:
-            return ""
+            return ()
 
         if vis == 2:
             if not self.is_optional:
-                return "y" if self.type == BOOL else "my"
-            return "y"
+                return (2,) if self.type == BOOL else (1, 2)
+            return (2,)
 
         # vis == 1
 
-        return "nm" if self.is_optional else "m"
+        return (0, 1) if self.is_optional else (1,)
 
     def _invalidate(self):
         self._cached_vis = self._cached_assignable = None
@@ -2881,7 +3148,7 @@ class MenuNode(object):
     menu node for each location.
 
     The top-level menu node, corresponding to the implicit top-level menu, is
-    available in Config.top_node.
+    available in Kconfig.top_node.
 
     For symbols and choices, the menu nodes are available in the 'nodes'
     attribute. Menus and comments are represented as plain menu nodes, with
@@ -2947,7 +3214,7 @@ class MenuNode(object):
         itself.
 
     config:
-        The Config the menu node is from.
+        The Kconfig the menu node is from.
 
     filename/linenr:
         The location where the menu node appears.
@@ -3067,14 +3334,14 @@ def expr_value(expr):
         oper, op1, op2 = expr
 
         # If both operands are strings...
-        if op1._type == STRING and op2._type == STRING:
+        if op1.orig_type == STRING and op2.orig_type == STRING:
             # ...then compare them lexicographically
             comp = _strcmp(op1.str_value, op2.str_value)
         else:
             # Otherwise, try to compare them as numbers...
             try:
-                comp = int(op1.str_value, _TYPE_TO_BASE[op1._type]) - \
-                       int(op2.str_value, _TYPE_TO_BASE[op2._type])
+                comp = int(op1.str_value, _TYPE_TO_BASE[op1.orig_type]) - \
+                       int(op2.str_value, _TYPE_TO_BASE[op2.orig_type])
             except ValueError:
                 # Fall back on a lexicographic comparison if the operands don't
                 # parse as numbers
@@ -3097,7 +3364,9 @@ def expr_str(expr):
     TODO
     """
     if isinstance(expr, Symbol):
-        return expr.name if not expr.is_constant else '"{}"'.format(expr.name)
+        if expr.is_constant:
+            return '"{}"'.format(escape(expr.name))
+        return expr.name
 
     if expr[0] == NOT:
         if isinstance(expr[1], Symbol):
@@ -3116,6 +3385,21 @@ def expr_str(expr):
                              _RELATION_TO_STR[expr[0]],
                              expr_str(expr[2]))
 
+_escape_re_sub = re.compile(r'(["\\])').sub
+_unescape_re_sub = re.compile(r"\\(.)").sub
+
+def escape(s):
+    """
+    TODO
+    """
+    return _escape_re_sub(r"\\\1", s)
+
+def unescape(s):
+    """
+    TODO
+    """
+    return _unescape_re_sub(r"\1", s)
+
 #
 # Internal functions
 #
@@ -3134,13 +3418,13 @@ def _get_visibility(sc):
             vis = max(vis, expr_value(node.prompt[1]))
 
     if isinstance(sc, Symbol) and sc.choice is not None:
-        if sc.choice._type == TRISTATE and sc._type != TRISTATE and \
+        if sc.choice.orig_type == TRISTATE and sc.orig_type != TRISTATE and \
            sc.choice.tri_value != 2:
             # Non-tristate choice symbols in tristate choices depend on the
             # choice being in mode "y"
             return 0
 
-        if sc._type == TRISTATE and vis == 1 and sc.choice.tri_value == 2:
+        if sc.orig_type == TRISTATE and vis == 1 and sc.choice.tri_value == 2:
             # Choice symbols with visibility "m" are not visible if the
             # choice has mode "y"
             return 0
@@ -3151,7 +3435,7 @@ def _get_visibility(sc):
     # infinite recursion if something really weird is done with MODULES, but
     # it's not a problem in practice.
     if vis == 1 and \
-       (sc._type != TRISTATE or not sc.config.modules.tri_value):
+       (sc.orig_type != TRISTATE or not sc.config.modules.tri_value):
         return 2
 
     return vis
@@ -3270,8 +3554,8 @@ def _sym_choice_str(sc):
             else:
                 lines.append("choice " + sc.name)
 
-        if node is sc.nodes[0] and sc.type != UNKNOWN:
-            indent_add(_TYPENAME[sc.type])
+        if node is sc.nodes[0] and sc.orig_type != UNKNOWN:
+            indent_add(_TYPENAME[sc.orig_type])
 
         if node.prompt is not None:
             prompt_str = 'prompt "{}"'.format(node.prompt[0])
@@ -3458,16 +3742,16 @@ def _finalize_choice(node):
 
     # If no type is specified for the choice, its type is that of
     # the first choice item with a specified type
-    if choice._type == UNKNOWN:
+    if choice.orig_type == UNKNOWN:
         for item in choice.syms:
-            if item._type != UNKNOWN:
-                choice._type = item._type
+            if item.orig_type != UNKNOWN:
+                choice.orig_type = item.orig_type
                 break
 
     # Each choice item of UNKNOWN type gets the type of the choice
     for item in choice.syms:
-        if item._type == UNKNOWN:
-            item._type = choice._type
+        if item.orig_type == UNKNOWN:
+            item.orig_type = choice.orig_type
 
 def _finalize_tree(node):
     """
@@ -3537,12 +3821,14 @@ def _finalize_tree(node):
     COMMENT,
 ) = range(2)
 
+# TODO: unpublic?
 TRI_TO_STR = {
     0: "n",
     1: "m",
     2: "y",
 }
 
+# TODO: unpublic?
 STR_TO_TRI = {
     "n": 0,
     "m": 1,
@@ -3681,6 +3967,9 @@ _id_keyword_re_match = re.compile(r"([\w./-]+)\s*").match
 # Regular expression for finding $-references to symbols in strings
 _sym_ref_re_search = re.compile(r"\$([A-Za-z0-9_]+)").search
 
+# TODO
+_conf_string_re_match = re.compile(r'"((?:[^\\"]|\\.)*)"').match
+
 # Strings to use for types
 _TYPENAME = {
     UNKNOWN:  "unknown",
@@ -3719,13 +4008,6 @@ _TYPE_TO_BASE = {
     UNKNOWN:  0,
 }
 
-# Map from tristate values to integers
-_TRI_TO_INT = {
-    "n": 0,
-    "m": 1,
-    "y": 2,
-}
-
 _RELATIONS = frozenset((
     EQUAL,
     UNEQUAL,
diff --git a/testsuite.py b/testsuite.py
index 4af7c19..2e4b2ec 100644
--- a/testsuite.py
+++ b/testsuite.py
@@ -35,9 +35,11 @@
 # All tests should pass. Report regressions to ulfalizer a.t Google's email
 # service.
 
+from kconfiglib import Kconfig, Symbol, Choice, COMMENT, MENU, \
+                       BOOL, TRISTATE, HEX, STRING, \
+                       KconfigSyntaxError, expr_value
 import difflib
 import errno
-import kconfiglib
 import os
 import platform
 import re
@@ -117,7 +119,7 @@ def get_comments(config):
     items = []
     def rec(node):
         if node is not None:
-             if node.item == kconfiglib.COMMENT:
+             if node.item == COMMENT:
                  items.append(node)
              rec(node.list)
              rec(node.next)
@@ -128,7 +130,7 @@ def get_menus(config):
     items = []
     def rec(node):
         if node is not None:
-             if node.item == kconfiglib.MENU:
+             if node.item == MENU:
                  items.append(node)
              rec(node.list)
              rec(node.next)
@@ -136,7 +138,7 @@ def get_menus(config):
     return items
 
 def get_choices(config):
-    choices = get_items(config, kconfiglib.Choice)
+    choices = get_items(config, Choice)
     unique_choices = []
     for choice in choices:
         if choice not in unique_choices:
@@ -144,7 +146,7 @@ def get_choices(config):
     return unique_choices
 
 def get_parent(item):
-    if isinstance(item, (kconfiglib.Symbol, kconfiglib.Choice)):
+    if isinstance(item, (Symbol, Choice)):
         if not item.nodes:
             return None
         return item.nodes[0].parent.item
@@ -157,6 +159,9 @@ def get_prompts(item):
             prompts.append(node.prompt[0])
     return prompts
 
+STR_TO_TRI = {"n": 0, "m": 1, "y": 2}
+TRI_TO_STR = {0: "n", 1: "m", 2: "y"}
+
 def run_selftests():
     #
     # Common helper functions. These all expect 'c' to hold the current
@@ -167,6 +172,10 @@ def run_selftests():
         """
         Verifies that a symbol has a particular value.
         """
+
+        if isinstance(val, int):
+            val = TRI_TO_STR[val]
+
         sym = c.syms[sym_name]
         verify(sym.str_value == val,
                'expected {} to have the value "{}", had the value "{}"'
@@ -177,6 +186,10 @@ def run_selftests():
         Assigns 'val' to a symbol and verifies that its value becomes
         'new_val'.
         """
+
+        if isinstance(new_val, int):
+            new_val = TRI_TO_STR[new_val]
+
         sym = c.syms[sym_name]
         old_val = sym.str_value
         sym.set_value(val)
@@ -194,9 +207,13 @@ def run_selftests():
         assign_and_verify_value(sym_name, user_val, user_val)
 
     def assign_and_verify_user_value(sym_name, val, user_val):
-        """Assigns a user value to the symbol and verifies the new user
-        value."""
+        """Assigns a user value to the symbol and verifies the new user value.
+        Also checks consistency of user_str_value and user_tri_value."""
         sym = c.syms[sym_name]
+
+        if sym.type in (BOOL, TRISTATE):
+            user_val = TRI_TO_STR[user_val]
+
         sym_old_user_val = sym.user_str_value
         sym.set_value(val)
         verify(sym.user_str_value == user_val,
@@ -206,14 +223,23 @@ def run_selftests():
                .format(sym_name, user_val, user_val, sym.user_str_value,
                        sym_old_user_val))
 
+        if sym.type in (BOOL, TRISTATE):
+            verify(sym.user_tri_value == STR_TO_TRI[sym.user_str_value],
+                   "{} has an inconsistent user value ('{}' vs '{}')"
+                   .format(sym_name, sym.user_tri_value, sym.user_str_value))
+        else:
+            verify(sym.user_tri_value == 0,
+                   "{} is non-bool/tristate and has the non-zero "
+                   "user_tri_value {}".format(sym_name, sym.user_tri_value))
+
     #
     # Selftests
     #
 
     print("Testing string literal lexing")
 
-    # Dummy empty configuration just to get a Config object
-    c = kconfiglib.Config("Kconfiglib/tests/empty")
+    # Dummy empty configuration just to get a Kconfig object
+    c = Kconfig("Kconfiglib/tests/empty")
 
     def verify_string_lex(s, res):
         """
@@ -261,7 +287,7 @@ def run_selftests():
         """
         try:
             c.eval_string(s)
-        except kconfiglib.KconfigSyntaxError:
+        except KconfigSyntaxError:
             pass
         else:
             fail("expected tokenization of {} to fail, didn't".format(s[1:-1]))
@@ -280,7 +306,7 @@ def run_selftests():
 
     print("Testing expression evaluation")
 
-    c = kconfiglib.Config("Kconfiglib/tests/Keval")
+    c = Kconfig("Kconfiglib/tests/Keval")
 
     def verify_eval(expr, val):
         res = c.eval_string(expr)
@@ -297,7 +323,7 @@ def run_selftests():
     verify_eval("M", 2)
 
     # Modules
-    c.modules.set_value("y")
+    c.modules.set_value(2)
     verify_eval("n", 0)
     verify_eval("m", 1)
     verify_eval("y", 2)
@@ -454,7 +480,7 @@ def run_selftests():
     def verify_eval_bad(expr):
         try:
             c.eval_string(expr)
-        except kconfiglib.KconfigSyntaxError:
+        except KconfigSyntaxError:
             pass
         else:
             fail('expected eval_string("{}") to throw KconfigSyntaxError, ' \
@@ -482,9 +508,9 @@ def run_selftests():
     def verify_str(item, s):
         verify_equal(str(item), s[1:])
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kstr", warn=False)
+    c = Kconfig("Kconfiglib/tests/Kstr", warn=False)
 
-    c.modules.set_value("y")
+    c.modules.set_value(2)
 
     verify_str(c.syms["UNDEFINED"], """
 """)
@@ -585,7 +611,7 @@ choice
     def verify_repr(item, s):
         verify_equal(repr(item) + "\n", s[1:])
 
-    c = kconfiglib.Config("Kconfiglib/tests/Krepr", warn=False)
+    c = Kconfig("Kconfiglib/tests/Krepr", warn=False)
 
     verify_repr(c.n, """
 <symbol n, tristate, value "n", constant>
@@ -611,7 +637,7 @@ choice
 <symbol VISIBLE, bool, "visible", value "n", visibility y, direct deps y, Kconfiglib/tests/Krepr:14>
 """)
 
-    c.syms["VISIBLE"].set_value("y")
+    c.syms["VISIBLE"].set_value(2)
 
     verify_repr(c.syms["VISIBLE"], """
 <symbol VISIBLE, bool, "visible", value "y", user value "y", visibility y, direct deps y, Kconfiglib/tests/Krepr:14>
@@ -644,19 +670,19 @@ choice
 <choice CHOICE, tristate, "choice", mode m, visibility y, Kconfiglib/tests/Krepr:30>
 """)
 
-    c.named_choices["CHOICE"].set_value("y")
+    c.named_choices["CHOICE"].set_value(2)
 
     verify_repr(c.named_choices["CHOICE"], """
 <choice CHOICE, tristate, "choice", mode y, user mode y, CHOICE_1 selected, visibility y, Kconfiglib/tests/Krepr:30>
 """)
 
-    c.syms["CHOICE_2"].set_value("y")
+    c.syms["CHOICE_2"].set_value(2)
 
     verify_repr(c.named_choices["CHOICE"], """
 <choice CHOICE, tristate, "choice", mode y, user mode y, CHOICE_2 selected, CHOICE_2 selected by user, visibility y, Kconfiglib/tests/Krepr:30>
 """)
 
-    c.syms["CHOICE_1"].set_value("m")
+    c.syms["CHOICE_1"].set_value(1)
 
     verify_repr(c.named_choices["CHOICE"], """
 <choice CHOICE, tristate, "choice", mode m, user mode m, CHOICE_2 selected by user (overriden), visibility y, Kconfiglib/tests/Krepr:30>
@@ -710,7 +736,7 @@ choice
 """)
 
 
-    print("Testing Config.__repr__()")
+    print("Testing Kconfig.__repr__()")
 
     verify_repr(c, """
 <configuration with 15 symbols, main menu prompt "Linux Kernel Configuration", srctree not set, config symbol prefix "CONFIG_", warnings disabled, undef. symbol assignment warnings disabled>
@@ -719,7 +745,7 @@ choice
     os.environ["srctree"] = "srctree value"
     os.environ["CONFIG_"] = "CONFIG_ value"
 
-    c = kconfiglib.Config("Kconfiglib/tests/Krepr", warn=False)
+    c = Kconfig("Kconfiglib/tests/Krepr", warn=False)
     c.enable_warnings()
     c.enable_undef_warnings()
 
@@ -733,7 +759,7 @@ choice
 
     print("Testing tricky help strings")
 
-    c = kconfiglib.Config("Kconfiglib/tests/Khelp")
+    c = Kconfig("Kconfiglib/tests/Khelp")
 
     def verify_help(node, s):
         verify_equal(node.help, s[1:])
@@ -794,7 +820,7 @@ g
     os.environ["EXPANDED_FROM_ENV"] = "tests"
     os.environ["srctree"] = "Kconfiglib/"
 
-    c = kconfiglib.Config("tests/Klocation")
+    c = Kconfig("tests/Klocation")
 
     os.environ.pop("EXPANDED_FROM_ENV", None)
     os.environ.pop("srctree", None)
@@ -819,16 +845,16 @@ g
 
     print("Testing visibility")
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kvisibility")
+    c = Kconfig("Kconfiglib/tests/Kvisibility")
 
     def verify_visibility(item, no_module_vis, module_vis):
-        c.modules.set_value("n")
+        c.modules.set_value(0)
         verify(item.visibility == no_module_vis,
                "expected {} to have visibility {} without modules, had "
                "visibility {}".
                format(repr(item), no_module_vis, item.visibility))
 
-	c.modules.set_value("y")
+        c.modules.set_value(2)
         verify(item.visibility == module_vis,
                "expected {} to have visibility {} with modules, had "
                "visibility {}".
@@ -860,8 +886,8 @@ g
     # type gets adjusted to bool.
     verify_visibility(c.syms["BOOL_CHOICE_Y"], 2, 0)
 
-    c.syms["TRISTATE_CHOICE_M"].set_value("y")
-    c.syms["TRISTATE_CHOICE_Y"].set_value("y")
+    c.syms["TRISTATE_CHOICE_M"].set_value(2)
+    c.syms["TRISTATE_CHOICE_Y"].set_value(2)
 
     # Still limited by the visibility of the choice
     verify_visibility(c.syms["BOOL_CHOICE_M"], 0, 0)
@@ -892,15 +918,15 @@ g
     # Menu visibility
 
     def verify_menu_visibility(menu, no_module_vis, module_vis):
-        c.modules.set_value("n")
-        menu_vis = kconfiglib.expr_value(menu.node.dep)
+        c.modules.set_value(0)
+        menu_vis = expr_value(menu.node.dep)
         verify(menu_vis == no_module_vis,
                "menu \"{}\" should have visibility '{}' without modules, "
                "has visibility '{}'"
                .format(menu.title, no_module_vis, menu_vis))
 
-	c.modules.set_value("y")
-        menu_vis = kconfiglib.expr_value(menu.node.dep)
+        c.modules.set_value(2)
+        menu_vis = expr_value(menu.node.dep)
         verify(menu_vis == module_vis,
                "menu \"{}\" should have visibility '{}' with modules, "
                "has visibility '{}'".
@@ -925,14 +951,14 @@ g
       menu_visible_if_m_2 = get_menus(c)[13:]
 
     def verify_visible_if_visibility(menu, no_module_vis, module_vis):
-        c.modules.set_value("n")
+        c.modules.set_value(0)
         menu_vis = menu.get_visible_if_visibility()
         verify(menu_vis == no_module_vis,
                "menu \"{}\" should have 'visible if' visibility '{}' "
                "without modules, has 'visible if' visibility '{}'".
                format(menu.title, no_module_vis, menu_vis))
 
-        c.modules.set_value("y")
+        c.modules.set_value(2)
         menu_vis = menu.get_visible_if_visibility()
         verify(menu_vis == module_vis,
                "menu \"{}\" should have 'visible if' visibility '{}' "
@@ -961,16 +987,16 @@ g
     # Comment visibility
 
     def verify_comment_visibility(comment, no_module_vis, module_vis):
-        c.modules.set_value("n")
+        c.modules.set_value(0)
         # TODO: uninternalize
-        comment_vis = kconfiglib.expr_value(comment.node.dep)
+        comment_vis = expr_value(comment.node.dep)
         verify(comment_vis == no_module_vis,
                "comment \"{}\" should have visibility '{}' without "
                "modules, has visibility '{}'".
                format(comment.text, no_module_vis, comment_vis))
 
-        c.modules.set_value("y")
-        comment_vis = kconfiglib.expr_value(comment.node.dep)
+        c.modules.set_value(2)
+        comment_vis = expr_value(comment.node.dep)
         verify(comment_vis == module_vis,
                "comment \"{}\" should have visibility '{}' with "
                "modules, has visibility '{}'".
@@ -999,7 +1025,7 @@ g
     # Object relations
     #
 
-    c = kconfiglib.Config("Kconfiglib/tests/Krelation")
+    c = Kconfig("Kconfiglib/tests/Krelation")
 
     UNDEFINED, A, B, C, D, E, F, G, H, I = \
         c.syms["UNDEFINED"], c.syms["A"], c.syms["B"], c.syms["C"], \
@@ -1043,7 +1069,7 @@ g
 
     print("Testing hex/int ranges...")
 
-    c = kconfiglib.Config("Kconfiglib/tests/Krange")
+    c = Kconfig("Kconfiglib/tests/Krange")
 
     for sym_name in "HEX_NO_RANGE", "INT_NO_RANGE", "HEX_40", "INT_40":
         sym = c.syms[sym_name]
@@ -1093,7 +1119,7 @@ g
         """Tests that the values in the range 'low'-'high' can be assigned, and
         that assigning values outside this range reverts the value back to
         'default' (None if it should revert back to "")."""
-        is_hex = (c.syms[sym_name].type == kconfiglib.HEX)
+        is_hex = (c.syms[sym_name].type == HEX)
         for i in range(low, high + 1):
             assign_and_verify_user_value(sym_name, str(i), str(i))
             if is_hex:
@@ -1166,11 +1192,11 @@ g
 
     print("Testing defconfig_filename...")
 
-    c = kconfiglib.Config("Kconfiglib/tests/empty")
+    c = Kconfig("Kconfiglib/tests/empty")
     verify(c.defconfig_filename is None,
            "defconfig_filename should be None with no defconfig_list symbol")
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_nonexistent")
+    c = Kconfig("Kconfiglib/tests/Kdefconfig_nonexistent")
     verify(c.defconfig_filename is None,
            "defconfig_filename should be None when none of the files in the "
            "defconfig_list symbol exist")
@@ -1178,12 +1204,12 @@ g
     # Referenced in Kdefconfig_existent(_but_n)
     os.environ["BAR"] = "defconfig_2"
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_existent_but_n")
+    c = Kconfig("Kconfiglib/tests/Kdefconfig_existent_but_n")
     verify(c.defconfig_filename is None,
            "defconfig_filename should be None when the condition is n for all "
            "the defaults")
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_existent")
+    c = Kconfig("Kconfiglib/tests/Kdefconfig_existent")
     verify(c.defconfig_filename == "Kconfiglib/tests/defconfig_2",
            "defconfig_filename should return the existent file "
            "Kconfiglib/tests/defconfig_2")
@@ -1191,12 +1217,12 @@ g
     # Should also look relative to $srctree if the defconfig is an absolute
     # path and not found
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_srctree")
+    c = Kconfig("Kconfiglib/tests/Kdefconfig_srctree")
     verify(c.defconfig_filename == "Kconfiglib/tests/defconfig_2",
            "defconfig_filename gave wrong file with $srctree unset")
 
     os.environ["srctree"] = "Kconfiglib/tests"
-    c = kconfiglib.Config("Kconfiglib/tests/Kdefconfig_srctree")
+    c = Kconfig("Kconfiglib/tests/Kdefconfig_srctree")
     verify(c.defconfig_filename == "Kconfiglib/tests/sub/defconfig_in_sub",
            "defconfig_filename gave wrong file with $srctree set")
 
@@ -1206,13 +1232,13 @@ g
 
     print("Testing mainmenu_text...")
 
-    c = kconfiglib.Config("Kconfiglib/tests/empty")
+    c = Kconfig("Kconfiglib/tests/empty")
     verify(c.mainmenu_text == "Linux Kernel Configuration",
            "An empty Kconfig should get a default main menu prompt")
 
     # Expanded in the mainmenu text
     os.environ["FOO"] = "bar baz"
-    c = kconfiglib.Config("Kconfiglib/tests/Kmainmenu")
+    c = Kconfig("Kconfiglib/tests/Kmainmenu")
     verify(c.mainmenu_text == "---bar baz---",
            "Wrong mainmenu text")
 
@@ -1222,7 +1248,7 @@ g
 
     os.environ["ENV_VAR"] = "foo"
     # Contains reference to undefined environment variable, so disable warnings
-    c = kconfiglib.Config("Kconfiglib/tests/Kmisc", warn=False)
+    c = Kconfig("Kconfiglib/tests/Kmisc", warn=False)
 
     print("Testing is_optional...")
 
@@ -1246,11 +1272,11 @@ g
 
     # Assign valid values for the types
 
-    assign_and_verify_user_value("BOOL", "n", "n")
-    assign_and_verify_user_value("BOOL", "y", "y")
-    assign_and_verify_user_value("TRISTATE", "n", "n")
-    assign_and_verify_user_value("TRISTATE", "m", "m")
-    assign_and_verify_user_value("TRISTATE", "y", "y")
+    assign_and_verify_user_value("BOOL", 0, 0)
+    assign_and_verify_user_value("BOOL", 2, 2)
+    assign_and_verify_user_value("TRISTATE", 0, 0)
+    assign_and_verify_user_value("TRISTATE", 1, 1)
+    assign_and_verify_user_value("TRISTATE", 2, 2)
     assign_and_verify_user_value("STRING", "foo bar", "foo bar")
     assign_and_verify_user_value("INT", "123", "123")
     assign_and_verify_user_value("HEX", "0x123", "0x123")
@@ -1258,13 +1284,16 @@ g
     # Assign invalid values for the types. They should retain their old user
     # value.
 
-    assign_and_verify_user_value("BOOL", "m", "y")
-    assign_and_verify_user_value("BOOL", "foo", "y")
-    assign_and_verify_user_value("BOOL", "1", "y")
-    assign_and_verify_user_value("TRISTATE", "foo", "y")
-    assign_and_verify_user_value("TRISTATE", "1", "y")
+    assign_and_verify_user_value("BOOL", 1, 2)
+    assign_and_verify_user_value("BOOL", "foo", 2)
+    assign_and_verify_user_value("BOOL", "1", 2)
+    assign_and_verify_user_value("TRISTATE", "foo", 2)
+    assign_and_verify_user_value("TRISTATE", "1", 2)
+    assign_and_verify_user_value("STRING", 0, "foo bar")
     assign_and_verify_user_value("INT", "foo", "123")
+    assign_and_verify_user_value("INT", 0, "123")
     assign_and_verify_user_value("HEX", "foo", "0x123")
+    assign_and_verify_user_value("HEX", 0, "0x123")
 
     for s in syms:
         s.unset_value()
@@ -1308,7 +1337,7 @@ g
     verify_value("UNAME_RELEASE", platform.uname()[2])
     ur = c.syms["UNAME_RELEASE"]
     verify(ur.config is c and
-           ur.type == kconfiglib.STRING and
+           ur.type == STRING and
            ur.env_var == "<uname release>",
            "UNAME_RELEASE has wrong fields")
 
@@ -1336,7 +1365,7 @@ g
 
     # Writing/reading strings with characters that need to be escaped
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kescape")
+    c = Kconfig("Kconfiglib/tests/Kescape")
 
     # Test the default value
     c.write_config(config_test_file + "_from_def", header="")
@@ -1356,7 +1385,7 @@ g
 
     # Appending values from a .config
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kappend")
+    c = Kconfig("Kconfiglib/tests/Kappend")
 
     # Values before assigning
     verify_value("BOOL", "n")
@@ -1391,8 +1420,8 @@ g
 
     print("Testing Config separation...")
 
-    c1 = kconfiglib.Config("Kconfiglib/tests/Kmisc", warn=False)
-    c2 = kconfiglib.Config("Kconfiglib/tests/Kmisc", warn=False)
+    c1 = Kconfig("Kconfiglib/tests/Kmisc", warn=False)
+    c2 = Kconfig("Kconfiglib/tests/Kmisc", warn=False)
 
     c1_undef, c1_bool, c1_choice, c1_menu, c1_comment = c1.syms["BOOL"], \
         c1.syms["NOT_DEFINED_1"], get_choices(c1)[0], get_menus(c1)[0], \
@@ -1417,7 +1446,7 @@ g
 
     print("Testing imply semantics...")
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kimply")
+    c = Kconfig("Kconfiglib/tests/Kimply")
 
     verify_value("IMPLY_DIRECT_DEPS", "y")
     verify_value("UNMET_DIRECT_1", "n")
@@ -1450,64 +1479,64 @@ g
     # Verify that IMPLIED_TRISTATE is invalidated if the direct
     # dependencies change
 
-    assign_and_verify("IMPLY", "y")
-    assign_and_verify("DIRECT_DEP", "y")
-    verify_value("IMPLIED_TRISTATE", "y")
-    assign_and_verify("DIRECT_DEP", "n")
-    verify_value("IMPLIED_TRISTATE", "n")
+    assign_and_verify("IMPLY", 2)
+    assign_and_verify("DIRECT_DEP", 2)
+    verify_value("IMPLIED_TRISTATE", 2)
+    assign_and_verify("DIRECT_DEP", 0)
+    verify_value("IMPLIED_TRISTATE", 0)
     # Set back for later tests
-    assign_and_verify("DIRECT_DEP", "y")
+    assign_and_verify("DIRECT_DEP", 2)
 
     # Verify that IMPLIED_TRISTATE can be set to anything when IMPLY has value
     # "n", and that it gets the value "n" by default (for non-imply-related
     # reasons)
 
-    assign_and_verify("IMPLY", "n")
-    assign_and_verify("IMPLIED_TRISTATE", "n")
-    assign_and_verify("IMPLIED_TRISTATE", "m")
-    assign_and_verify("IMPLIED_TRISTATE", "y")
+    assign_and_verify("IMPLY", 0)
+    assign_and_verify("IMPLIED_TRISTATE", 0)
+    assign_and_verify("IMPLIED_TRISTATE", 1)
+    assign_and_verify("IMPLIED_TRISTATE", 2)
     c.syms["IMPLIED_TRISTATE"].unset_value()
     verify_value("IMPLIED_TRISTATE", "n")
 
     # Same as above for "m". Anything still goes, but "m" by default now.
 
-    assign_and_verify("IMPLY", "m")
-    assign_and_verify("IMPLIED_TRISTATE", "n")
-    assign_and_verify("IMPLIED_TRISTATE", "m")
-    assign_and_verify("IMPLIED_TRISTATE", "y")
+    assign_and_verify("IMPLY", 1)
+    assign_and_verify("IMPLIED_TRISTATE", 0)
+    assign_and_verify("IMPLIED_TRISTATE", 1)
+    assign_and_verify("IMPLIED_TRISTATE", 2)
     c.syms["IMPLIED_TRISTATE"].unset_value()
-    verify_value("IMPLIED_TRISTATE", "m")
+    verify_value("IMPLIED_TRISTATE", 1)
 
     # Same as above for "y". Only "n" and "y" should be accepted. "m" gets
     # promoted to "y". Default should be "y".
 
-    assign_and_verify("IMPLY", "y")
-    assign_and_verify("IMPLIED_TRISTATE", "n")
-    assign_and_verify_value("IMPLIED_TRISTATE", "m", "y")
-    assign_and_verify("IMPLIED_TRISTATE", "y")
+    assign_and_verify("IMPLY", 2)
+    assign_and_verify("IMPLIED_TRISTATE", 0)
+    assign_and_verify_value("IMPLIED_TRISTATE", 1, 2)
+    assign_and_verify("IMPLIED_TRISTATE", 2)
     c.syms["IMPLIED_TRISTATE"].unset_value()
-    verify_value("IMPLIED_TRISTATE", "y")
+    verify_value("IMPLIED_TRISTATE", 2)
 
     # Being implied to either "m" or "y" should give a bool the value "y"
 
     c.syms["IMPLY"].unset_value()
-    verify_value("IMPLIED_BOOL", "n")
-    assign_and_verify("IMPLY", "n")
-    verify_value("IMPLIED_BOOL", "n")
-    assign_and_verify("IMPLY", "m")
-    verify_value("IMPLIED_BOOL", "y")
-    assign_and_verify("IMPLY", "y")
-    verify_value("IMPLIED_BOOL", "y")
+    verify_value("IMPLIED_BOOL", 0)
+    assign_and_verify("IMPLY", 0)
+    verify_value("IMPLIED_BOOL", 0)
+    assign_and_verify("IMPLY", 1)
+    verify_value("IMPLIED_BOOL", 2)
+    assign_and_verify("IMPLY", 2)
+    verify_value("IMPLIED_BOOL", 2)
 
     # A bool implied to "m" or "y" can take the values "n" and "y"
 
-    c.syms["IMPLY"].set_value("m")
-    assign_and_verify("IMPLIED_BOOL", "n")
-    assign_and_verify("IMPLIED_BOOL", "y")
+    c.syms["IMPLY"].set_value(1)
+    assign_and_verify("IMPLIED_BOOL", 0)
+    assign_and_verify("IMPLIED_BOOL", 2)
 
-    c.syms["IMPLY"].set_value("y")
-    assign_and_verify("IMPLIED_BOOL", "n")
-    assign_and_verify("IMPLIED_BOOL", "y")
+    c.syms["IMPLY"].set_value(2)
+    assign_and_verify("IMPLIED_BOOL", 0)
+    assign_and_verify("IMPLIED_BOOL", 2)
 
     #
     # Choice semantics
@@ -1515,7 +1544,7 @@ g
 
     print("Testing choice semantics...")
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kchoice")
+    c = Kconfig("Kconfiglib/tests/Kchoice")
 
     choice_bool, choice_bool_opt, choice_tristate, choice_tristate_opt, \
       choice_bool_m, choice_tristate_m, choice_defaults, \
@@ -1525,18 +1554,18 @@ g
 
     for choice in (choice_bool, choice_bool_opt, choice_bool_m,
                    choice_defaults):
-        verify(choice.type == kconfiglib.BOOL,
+        verify(choice.type == BOOL,
                "choice {} should have type bool".format(choice.name))
 
     # TODO: fix this laters. type automatically changed.
     #for choice in (choice_tristate, choice_tristate_opt, choice_tristate_m):
-    #    verify(choice.type == kconfiglib.TRISTATE,
+    #    verify(choice.type == TRISTATE,
     #           "choice {} should have type tristate"
     #           .format(choice.name))
 
     def select_and_verify(sym):
         choice = get_parent(sym)
-        sym.set_value("y")
+        sym.set_value(2)
         verify(choice.str_value == "y",
                "The mode of the choice should be y after selecting a symbol")
         verify(sym.choice.selection is sym,
@@ -1557,13 +1586,13 @@ g
             select_and_verify(choice.syms[i])
 
     def verify_mode(choice, no_modules_mode, modules_mode):
-        c.modules.set_value("n")
+        c.modules.set_value(0)
         choice_mode = choice.tri_value
         verify(choice_mode == no_modules_mode,
                'Wrong mode for choice {} with no modules. Expected {}, got {}.'
                .format(choice.name, no_modules_mode, choice_mode))
 
-        c.modules.set_value("y")
+        c.modules.set_value(2)
         choice_mode = choice.tri_value
         verify(choice_mode == modules_mode,
                'Wrong mode for choice {} with modules. Expected {}, got {}.'
@@ -1578,13 +1607,13 @@ g
 
     # Test defaults
 
-    c.syms["TRISTATE_SYM"].set_value("n")
+    c.syms["TRISTATE_SYM"].set_value(0)
     verify(choice_defaults.selection is c.syms["OPT_4"],
            "Wrong choice default with TRISTATE_SYM = n")
-    c.syms["TRISTATE_SYM"].set_value("y")
+    c.syms["TRISTATE_SYM"].set_value(2)
     verify(choice_defaults.selection is c.syms["OPT_2"],
            "Wrong choice default with TRISTATE_SYM = y")
-    c.syms["OPT_1"].set_value("y")
+    c.syms["OPT_1"].set_value(2)
     verify(choice_defaults.selection is c.syms["OPT_1"],
            "User selection should override defaults")
 
@@ -1594,7 +1623,7 @@ g
 
     # Test "y" mode selection
 
-    c.modules.set_value("y")
+    c.modules.set_value(2)
 
     select_and_verify_all(choice_bool)
     select_and_verify_all(choice_bool_opt)
@@ -1608,12 +1637,12 @@ g
     # ...for a choice that can also be in "y" mode
 
     for sym_name in ("T_1", "T_2"):
-        assign_and_verify_value(sym_name, "m", "m")
+        assign_and_verify_value(sym_name, 1, 1)
         verify(choice_tristate.tri_value == 1,
                'Selecting {} to "m" should have changed the mode of the '
                'choice to "m"'.format(sym_name))
 
-        assign_and_verify_value(sym_name, "y", "y")
+        assign_and_verify_value(sym_name, 2, 2)
         verify(choice_tristate.tri_value == 2 and
                choice_tristate.selection is c.syms[sym_name],
                'Selecting {} to "y" should have changed the mode of the '
@@ -1622,32 +1651,31 @@ g
     # ...for a choice that can only be in "m" mode
 
     for sym_name in ("TM_1", "TM_2"):
-        assign_and_verify_value(sym_name, "m", "m")
-        assign_and_verify_value(sym_name, "n", "n")
+        assign_and_verify_value(sym_name, 1, 1)
+        assign_and_verify_value(sym_name, 0, 0)
         # "y" should be truncated
-        assign_and_verify_value(sym_name, "y", "m")
+        assign_and_verify_value(sym_name, 2, 1)
         verify(choice_tristate_m.tri_value == 1,
-               'A choice that can only be in "m" mode was not')
+               'A choice that can only be in m mode was not')
 
     # Verify that choices with no explicitly specified type get the type of the
     # first contained symbol with a type
 
-    verify(choice_no_type_bool.type == kconfiglib.BOOL,
+    verify(choice_no_type_bool.type == BOOL,
            "Expected first choice without explicit type to have type bool")
-    verify(choice_no_type_tristate.type == kconfiglib.TRISTATE,
+    verify(choice_no_type_tristate.type == TRISTATE,
            "Expected second choice without explicit type to have type "
            "tristate")
 
     # Verify that symbols without a type in the choice get the type of the
     # choice
 
-    verify((c.syms["MMT_1"]._type, c.syms["MMT_2"]._type,
-            c.syms["MMT_3"]._type) ==
-             (kconfiglib.BOOL, kconfiglib.BOOL, kconfiglib.TRISTATE),
+    verify((c.syms["MMT_1"].orig_type, c.syms["MMT_2"].orig_type,
+            c.syms["MMT_3"].orig_type) == (BOOL, BOOL, TRISTATE),
            "Wrong types for first choice with missing member types")
 
-    verify((c.syms["MMT_4"]._type, c.syms["MMT_5"]._type) ==
-             (kconfiglib.BOOL, kconfiglib.BOOL),
+    verify((c.syms["MMT_4"].orig_type, c.syms["MMT_5"].orig_type) ==
+             (BOOL, BOOL),
            "Wrong types for second choice with missing member types")
 
     # Verify that symbols in choices that depend on the preceding symbol aren't
@@ -1687,7 +1715,7 @@ g
 
     # Note: This tests an internal API
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kdep")
+    c = Kconfig("Kconfiglib/tests/Kdep")
 
     def verify_dependent(sym_name, deps_names):
         sym = c.syms[sym_name]
@@ -1696,7 +1724,7 @@ g
         verify(len(sym_deps) == len(set(sym_deps)),
                "{}'s dependencies contains duplicates".format(sym_name))
         sym_deps = [item for item in sym_deps
-                         if not isinstance(item, kconfiglib.Choice)]
+                         if not isinstance(item, Choice)]
         verify(len(sym_deps) == len(deps),
                "Wrong number of dependent symbols for {}".format(sym_name))
         for dep in deps:
@@ -1717,7 +1745,7 @@ g
     # Verify that the last symbol depends on the first in a long chain of
     # dependencies. Test twice to cover dependency caching.
 
-    c = kconfiglib.Config("Kconfiglib/tests/Kchain")
+    c = Kconfig("Kconfiglib/tests/Kchain")
 
     for i in range(0, 2):
         verify(c.syms["CHAIN_26"] in c.syms["CHAIN_1"]._get_dependent(),
@@ -1728,7 +1756,7 @@ g
     # Check that Kconfiglib doesn't crash for stuff like 'select n' (seen in
     # U-Boot). These probably originate from misunderstandings of how Kconfig
     # works.
-    kconfiglib.Config("Kconfiglib/tests/Kwtf")
+    Kconfig("Kconfiglib/tests/Kwtf")
 
     print("\nAll selftests passed\n" if all_passed else
           "\nSome selftests failed\n")
@@ -1754,15 +1782,15 @@ def run_compatibility_tests():
     # 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_load,           False),
+    all_arch_tests = ((test_load,           False),
                       (test_alldefconfig,   True),
+                      (test_defconfig,      False),
                       (test_sanity,         False),
                       (test_all_no,         True),
                       (test_all_no_simpler, True),
-                      (test_all_yes,        True),
+                      (test_all_yes,        True))
                       # Needs to report success/failure for each arch/defconfig
                       # combo, hence False.
-                      (test_defconfig,      False)]
 
     arch_srcarch_list = get_arch_srcarch_list()
 
@@ -1779,7 +1807,7 @@ def run_compatibility_tests():
             # Previously we used to load all the arches once and keep them
             # around for the tests. That now uses a huge amount of memory (pypy
             # helps a bit), so reload them for each test instead.
-            test_fn(kconfiglib.Config(), arch)
+            test_fn(Kconfig(), arch)
 
             # Let kbuild infer SRCARCH from ARCH if we aren't in speedy mode.
             # This could detect issues with the test suite.
@@ -1900,7 +1928,9 @@ def test_sanity(conf, arch):
     conf.unset_values()
 
     # Python 2/3 compatible
-    for _, sym in conf.syms.items():
+    for key, sym in conf.syms.items():
+        verify(isinstance(key, str), "weird key '{}' in syms dict".format(key))
+
         if sym.name != "UNAME_RELEASE":
             verify(not sym.is_constant, sym.name + " in 'syms' and constant")
 
@@ -1916,7 +1946,8 @@ def test_sanity(conf, arch):
         sym.__str__()
         sym.assignable
         conf.disable_warnings()
-        sym.set_value("y")
+        sym.set_value(2)
+        sym.set_value("foo")
         conf.enable_warnings()
         sym.str_value
         sym.tri_value
@@ -1929,24 +1960,33 @@ def test_sanity(conf, arch):
     for sym in conf.defined_syms:
        verify(sym.nodes, sym.name + " is defined but lacks menu nodes")
 
-    for _, sym in conf.const_syms.items():
+       verify(not (sym.orig_type not in (BOOL, TRISTATE) and sym.choice),
+              sym.name + " is a choice symbol but not bool/tristate")
+
+    for key, sym in conf.const_syms.items():
+        verify(isinstance(key, str),
+               "weird key '{}' in const_syms dict".format(key))
+
         verify(sym.is_constant,
                '"{}" is in const_syms but not marked constant'
                .format(sym.name))
 
         verify(not sym.nodes,
-               '"{}" is constant but has menu nodes'
-               .format(sym.name))
+               '"{}" is constant but has menu nodes'.format(sym.name))
 
         verify(not sym._direct_dependents,
                '"{}" is constant but is a dependency of some symbol'
                .format(sym.name))
 
+        verify(not sym.choice,
+               '"{}" is constant and a choice symbol'.format(sym.name))
+
         sym.__repr__()
         sym.__str__()
         sym.assignable
         conf.disable_warnings()
-        sym.set_value("y")
+        sym.set_value(2)
+        sym.set_value("foo")
         conf.enable_warnings()
         sym.str_value
         sym.tri_value
@@ -1955,18 +1995,27 @@ def test_sanity(conf, arch):
         sym.visibility
 
     # Cheat with internals
-    for c in conf._choices:
-        c.__str__()
-        c.__repr__()
-        c.str_value
-        c.tri_value
-        c.user_str_value
-        c.user_tri_value
-        c.assignable
-        c.selection
-        c.default_selection
-        c.type
-        c.visibility
+    for choice in conf._choices:
+        for sym in choice.syms:
+            verify(sym.choice is choice,
+                   "{0} is in choice.syms but 'sym.choice' is not the choice"
+                   .format(sym.name))
+
+            verify(sym.type in (BOOL, TRISTATE),
+                   "{} is a choice symbol but is not a bool/tristate"
+                   .format(sym.name))
+
+        choice.__str__()
+        choice.__repr__()
+        choice.str_value
+        choice.tri_value
+        choice.user_str_value
+        choice.user_tri_value
+        choice.assignable
+        choice.selection
+        choice.default_selection
+        choice.type
+        choice.visibility
 
     # Menu nodes
 
@@ -1975,6 +2024,9 @@ def test_sanity(conf, arch):
     while 1:
         # Everything else should be well exercised elsewhere
         node.__repr__()
+        verify(isinstance(node.item, (Symbol, Choice)) or \
+               node.item in (MENU, COMMENT),
+               "'{}' appeared as a menu item".format(node.item))
 
         if node.list is not None:
             node = node.list
-- 
cgit v1.2.3