From 80d8ced2d8cc67ee11186a8bc24eb768ae559387 Mon Sep 17 00:00:00 2001
From: Dong Heng <dongheng@espressif.com>
Date: Thu, 3 May 2018 16:23:20 +0800
Subject: [PATCH 1/5] chore(kconfig): Update kconfig tools

---
 tools/kconfig/Makefile | 50 ++++++++++++++++++++++++++++++++++--------
 tools/kconfig/zconf.l  |  2 +-
 2 files changed, 42 insertions(+), 10 deletions(-)

diff --git a/tools/kconfig/Makefile b/tools/kconfig/Makefile
index 6675294b..c8a56abd 100644
--- a/tools/kconfig/Makefile
+++ b/tools/kconfig/Makefile
@@ -2,6 +2,10 @@
 # Kernel configuration targets
 # These targets are used from top-level makefile
 
+# SRCDIR is kconfig source dir, allows for out-of-tree builds
+# if building in tree, SRCDIR==build dir
+SRCDIR := $(abspath $(dir $(firstword $(MAKEFILE_LIST))))
+
 PHONY += xconfig gconfig menuconfig config silentoldconfig \
 	localmodconfig localyesconfig clean
 
@@ -23,6 +27,22 @@ CFLAGS :=
 CPPFLAGS :=
 LDFLAGS :=
 
+# Workaround for a bug on Windows if the mingw32 host compilers
+# are installed in addition to the MSYS ones. The kconfig tools
+# need to be compiled using the MSYS compiler.
+#
+# See https://github.com/espressif/esp-idf/issues/1296
+ifdef MSYSTEM
+ifeq ("$(MSYSTEM)", "MINGW32")
+ifeq ("$(CC)", "cc")
+CC := /usr/bin/gcc
+endif
+ifeq ("$(LD)", "ld")
+LD := /usr/bin/ld
+endif
+endif # MING32
+endif # MSYSTEM
+
 default: mconf conf
 
 xconfig: qconf
@@ -140,13 +160,22 @@ help:
 	@echo  '  tinyconfig	  - Configure the tiniest possible kernel'
 
 # lxdialog stuff
-check-lxdialog  := lxdialog/check-lxdialog.sh
+check-lxdialog  := $(SRCDIR)/lxdialog/check-lxdialog.sh
 
 # Use recursively expanded variables so we do not call gcc unless
 # we really need to do so. (Do not call gcc as part of make mrproper)
 CFLAGS += $(shell $(CONFIG_SHELL) $(check-lxdialog) -ccflags) \
                     -DLOCALE -MD
 
+%.o: $(SRCDIR)/%.c
+	$(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
+
+lxdialog/%.o: $(SRCDIR)/lxdialog/%.c
+	$(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
+
+%.o: %.c
+	$(CC) -I $(SRCDIR) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
+
 # ===========================================================================
 # Shared Makefile for the various kconfig executables:
 # conf:	  Used for defconfig, oldconfig and related targets
@@ -183,9 +212,12 @@ clean-files += $(all-objs) $(all-deps) conf mconf
 # Check that we have the required ncurses stuff installed for lxdialog (menuconfig)
 PHONY += dochecklxdialog
 $(addprefix ,$(lxdialog)): dochecklxdialog
-dochecklxdialog:
+dochecklxdialog: lxdialog
 	$(CONFIG_SHELL) $(check-lxdialog) -check $(CC) $(CFLAGS) $(LOADLIBES_mconf)
 
+lxdialog:
+	mkdir -p lxdialog
+
 always := dochecklxdialog
 
 # Add environment specific flags
@@ -292,7 +324,7 @@ gconf.glade.h: gconf.glade
 	gconf.glade
 
 
-mconf: $(mconf-objs)
+mconf: lxdialog $(mconf-objs)
 	$(CC) -o $@ $(mconf-objs) $(LOADLIBES_mconf)
 
 conf: $(conf-objs)
@@ -300,15 +332,15 @@ conf: $(conf-objs)
 
 zconf.tab.c: zconf.lex.c
 
-zconf.lex.c: zconf.l
-	flex -L -P zconf -o zconf.lex.c zconf.l
+zconf.lex.c: $(SRCDIR)/zconf.l
+	flex -L -P zconf -o zconf.lex.c $<
 
-zconf.hash.c: zconf.gperf
+zconf.hash.c: $(SRCDIR)/zconf.gperf
 # strip CRs on Windows systems where gperf will otherwise barf on them
-	sed -E "s/\\x0D$$//" zconf.gperf | gperf -t --output-file zconf.hash.c -a -C -E -g -k '1,3,$$' -p -t
+	sed -E "s/\\x0D$$//" $< | gperf -t --output-file zconf.hash.c -a -C -E -g -k '1,3,$$' -p -t
 
-zconf.tab.c: zconf.y
-	bison -t -l -p zconf -o zconf.tab.c zconf.y
+zconf.tab.c: $(SRCDIR)/zconf.y
+	bison -t -l -p zconf -o zconf.tab.c $<
 
 clean:
 	rm -f $(clean-files)
diff --git a/tools/kconfig/zconf.l b/tools/kconfig/zconf.l
index f0b65608..8fd75491 100644
--- a/tools/kconfig/zconf.l
+++ b/tools/kconfig/zconf.l
@@ -1,5 +1,5 @@
 %option nostdinit noyywrap never-interactive full ecs
-%option 8bit nodefault perf-report perf-report
+%option 8bit perf-report perf-report
 %option noinput
 %x COMMAND HELP STRING PARAM
 %{

From 9e3b31f644e15a8d6f193639e2415f1b1fbbb20c Mon Sep 17 00:00:00 2001
From: Dong Heng <dongheng@espressif.com>
Date: Thu, 3 May 2018 16:24:05 +0800
Subject: [PATCH 2/5] chore(kconfig_new): Add kconfig_new tools

---
 tools/kconfig_new/confgen.py         |  206 ++
 tools/kconfig_new/gen_kconfig_doc.py |  137 +
 tools/kconfig_new/kconfiglib.py      | 4317 ++++++++++++++++++++++++++
 3 files changed, 4660 insertions(+)
 create mode 100755 tools/kconfig_new/confgen.py
 create mode 100644 tools/kconfig_new/gen_kconfig_doc.py
 create mode 100644 tools/kconfig_new/kconfiglib.py

diff --git a/tools/kconfig_new/confgen.py b/tools/kconfig_new/confgen.py
new file mode 100755
index 00000000..13c74150
--- /dev/null
+++ b/tools/kconfig_new/confgen.py
@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+#
+# Command line tool to take in ESP-IDF sdkconfig files with project
+# settings and output data in multiple formats (update config, generate
+# header file, generate .cmake include file, documentation, etc).
+#
+# Used internally by the ESP-IDF build system. But designed to be
+# non-IDF-specific.
+#
+# Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http:#www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import argparse
+import sys
+import os
+import os.path
+import tempfile
+import json
+
+import gen_kconfig_doc
+import kconfiglib
+
+__version__ = "0.1"
+
+def main():
+    parser = argparse.ArgumentParser(description='confgen.py v%s - Config Generation Tool' % __version__, prog=os.path.basename(sys.argv[0]))
+
+    parser.add_argument('--config',
+                        help='Project configuration settings',
+                        nargs='?',
+                        default=None)
+
+    parser.add_argument('--defaults',
+                        help='Optional project defaults file, used if --config file doesn\'t exist',
+                        nargs='?',
+                        default=None)
+
+    parser.add_argument('--create-config-if-missing',
+                        help='If set, a new config file will be saved if the old one is not found',
+                        action='store_true')
+
+    parser.add_argument('--kconfig',
+                        help='KConfig file with config item definitions',
+                        required=True)
+
+    parser.add_argument('--output', nargs=2, action='append',
+                        help='Write output file (format and output filename)',
+                        metavar=('FORMAT', 'FILENAME'),
+                        default=[])
+
+    parser.add_argument('--env', action='append', default=[],
+                        help='Environment to set when evaluating the config file', metavar='NAME=VAL')
+
+    args = parser.parse_args()
+
+    for fmt, filename in args.output:
+        if not fmt in OUTPUT_FORMATS.keys():
+            print("Format '%s' not recognised. Known formats: %s" % (fmt, OUTPUT_FORMATS))
+            sys.exit(1)
+
+    try:
+       args.env = [ (name,value) for (name,value) in ( e.split("=",1) for e in args.env) ]
+    except ValueError:
+       print("--env arguments must each contain =. To unset an environment variable, use 'ENV='")
+       sys.exit(1)
+
+    for name, value in args.env:
+        os.environ[name] = value
+
+    config = kconfiglib.Kconfig(args.kconfig)
+
+    if args.defaults is not None:
+        # always load defaults first, so any items which are not defined in that config
+        # will have the default defined in the defaults file
+        if not os.path.exists(args.defaults):
+            raise RuntimeError("Defaults file not found: %s" % args.defaults)
+        config.load_config(args.defaults)
+
+    if args.config is not None:
+        if os.path.exists(args.config):
+            config.load_config(args.config)
+        elif args.create_config_if_missing:
+            print("Creating config file %s..." % args.config)
+            config.write_config(args.config)
+        elif args.default is None:
+            raise RuntimeError("Config file not found: %s" % args.config)
+
+        for output_type, filename in args.output:
+            temp_file = tempfile.mktemp(prefix="confgen_tmp")
+            try:
+                output_function = OUTPUT_FORMATS[output_type]
+                output_function(config, temp_file)
+                update_if_changed(temp_file, filename)
+            finally:
+                try:
+                    os.remove(temp_file)
+                except OSError:
+                    pass
+
+
+def write_config(config, filename):
+    CONFIG_HEADING = """#
+# Automatically generated file. DO NOT EDIT.
+# Espressif IoT Development Framework (ESP-IDF) Project Configuration
+#
+"""
+    config.write_config(filename, header=CONFIG_HEADING)
+
+def write_header(config, filename):
+    CONFIG_HEADING = """/*
+ * Automatically generated file. DO NOT EDIT.
+ * Espressif IoT Development Framework (ESP-IDF) Configuration Header
+ */
+#pragma once
+"""
+    config.write_autoconf(filename, header=CONFIG_HEADING)
+
+def write_cmake(config, filename):
+    with open(filename, "w") as f:
+        write = f.write
+        prefix = config.config_prefix
+
+        write("""#
+# Automatically generated file. DO NOT EDIT.
+# Espressif IoT Development Framework (ESP-IDF) Configuration cmake include file
+#
+""")
+        def write_node(node):
+            sym = node.item
+            if not isinstance(sym, kconfiglib.Symbol):
+                return
+
+            # Note: str_value calculates _write_to_conf, due to
+            # internal magic in kconfiglib...
+            val = sym.str_value
+            if sym._write_to_conf:
+                if sym.orig_type in (kconfiglib.BOOL, kconfiglib.TRISTATE) and val == "n":
+                    val = ""  # write unset values as empty variables
+                write("set({}{} \"{}\")\n".format(
+                    prefix, sym.name, val))
+        config.walk_menu(write_node)
+
+def write_json(config, filename):
+    config_dict = {}
+
+    def write_node(node):
+        sym = node.item
+        if not isinstance(sym, kconfiglib.Symbol):
+            return
+
+        val = sym.str_value  # this calculates _write_to_conf, due to kconfiglib magic
+        if sym._write_to_conf:
+            if sym.type in [ kconfiglib.BOOL, kconfiglib.TRISTATE ]:
+                val = (val != "n")
+            elif sym.type == kconfiglib.HEX:
+                val = int(val, 16)
+            elif sym.type == kconfiglib.INT:
+                val = int(val)
+            config_dict[sym.name] = val
+    config.walk_menu(write_node)
+    with open(filename, "w") as f:
+        json.dump(config_dict, f, indent=4, sort_keys=True)
+
+def update_if_changed(source, destination):
+    with open(source, "r") as f:
+        source_contents = f.read()
+    if os.path.exists(destination):
+        with open(destination, "r") as f:
+            dest_contents = f.read()
+        if source_contents == dest_contents:
+            return  # nothing to update
+
+    with open(destination, "w") as f:
+        f.write(source_contents)
+
+
+OUTPUT_FORMATS = {
+    "config" : write_config,
+    "header" : write_header,
+    "cmake" : write_cmake,
+    "docs" : gen_kconfig_doc.write_docs,
+    "json" : write_json,
+    }
+
+class FatalError(RuntimeError):
+    """
+    Class for runtime errors (not caused by bugs but by user input).
+    """
+    pass
+
+if __name__ == '__main__':
+    try:
+        main()
+    except FatalError as e:
+        print("A fatal error occurred: %s" % e)
+        sys.exit(2)
diff --git a/tools/kconfig_new/gen_kconfig_doc.py b/tools/kconfig_new/gen_kconfig_doc.py
new file mode 100644
index 00000000..e5e6968f
--- /dev/null
+++ b/tools/kconfig_new/gen_kconfig_doc.py
@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# gen_kconfig_doc - confgen.py support for generating ReST markup documentation
+#
+# For each option in the loaded Kconfig (e.g. 'FOO'), CONFIG_FOO link target is
+# generated, allowing options to be referenced in other documents
+# (using :ref:`CONFIG_FOO`)
+#
+# Copyright 2017-2018 Espressif Systems (Shanghai) PTE LTD
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http:#www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+import kconfiglib
+
+# Indentation to be used in the generated file
+INDENT = '    '
+
+# Characters used when underlining section heading
+HEADING_SYMBOLS = '#*=-^"+'
+
+# Keep the heading level in sync with api-reference/kconfig.rst
+INITIAL_HEADING_LEVEL = 3
+MAX_HEADING_LEVEL = len(HEADING_SYMBOLS)-1
+
+def write_docs(config, filename):
+    """ Note: writing .rst documentation ignores the current value
+    of any items. ie the --config option can be ignored.
+    (However at time of writing it still needs to be set to something...) """
+    with open(filename, "w") as f:
+        config.walk_menu(lambda node: write_menu_item(f, node))
+
+
+def get_breadcrumbs(node):
+    # this is a bit wasteful as it recalculates each time, but still...
+    result = []
+    node = node.parent
+    while node.parent:
+        if node.prompt:
+            result = [ node.prompt[0] ] + result
+        node = node.parent
+    return " > ".join(result)
+
+def get_heading_level(node):
+    # bit wasteful also
+    result = INITIAL_HEADING_LEVEL
+    node = node.parent
+    while node.parent:
+        result += 1
+        if result == MAX_HEADING_LEVEL:
+            return MAX_HEADING_LEVEL
+        node = node.parent
+    return result
+
+def format_rest_text(text, indent):
+    # Format an indented text block for use with ReST
+    text = indent + text.replace('\n', '\n' + indent)
+    # Escape some characters which are inline formatting in ReST
+    text = text.replace("*", "\\*")
+    text = text.replace("_", "\\_")
+    text += '\n'
+    return text
+
+def write_menu_item(f, node):
+    if not node.prompt:
+        return  # Don't do anything for invisible menu items
+
+    if isinstance(node.parent.item, kconfiglib.Choice):
+        return  # Skip choice nodes, they are handled as part of the parent (see below)
+
+    try:
+        name = node.item.name
+    except AttributeError:
+        name = None
+
+    try:
+        is_menu = node.item == kconfiglib.MENU or node.is_menuconfig
+    except AttributeError:
+        is_menu = False  # not all MenuNodes have is_menuconfig for some reason
+
+    ## Heading
+    if name:
+        title = name
+        # add link target so we can use :ref:`CONFIG_FOO`
+        f.write('.. _CONFIG_%s:\n\n' % name)
+    else:
+        title = node.prompt[0]
+
+    # if no symbol name, use the prompt as the heading
+    if True or is_menu:
+        f.write('%s\n' % title)
+        f.write(HEADING_SYMBOLS[get_heading_level(node)] * len(title))
+        f.write('\n\n')
+    else:
+        f.write('**%s**\n\n\n' % title)
+
+    if name:
+        f.write('%s%s\n\n' % (INDENT, node.prompt[0]))
+        f.write('%s:emphasis:`Found in: %s`\n\n' % (INDENT, get_breadcrumbs(node)))
+
+    try:
+        if node.help:
+            # Help text normally contains newlines, but spaces at the beginning of
+            # each line are stripped by kconfiglib. We need to re-indent the text
+            # to produce valid ReST.
+            f.write(format_rest_text(node.help, INDENT))
+    except AttributeError:
+        pass  # No help
+
+    if isinstance(node.item, kconfiglib.Choice):
+        f.write('%sAvailable options:\n' % INDENT)
+        choice_node = node.list
+        while choice_node:
+            # Format available options as a list
+            f.write('%s- %-20s (%s)\n' % (INDENT * 2, choice_node.prompt[0], choice_node.item.name))
+            if choice_node.help:
+                HELP_INDENT = INDENT * 2
+                fmt_help = format_rest_text(choice_node.help, '  ' + HELP_INDENT)
+                f.write('%s  \n%s\n' % (HELP_INDENT, fmt_help))
+            choice_node = choice_node.next
+
+        f.write('\n\n')
+
+
+if __name__ == '__main__':
+    print("Run this via 'confgen.py --output doc FILENAME'")
+
diff --git a/tools/kconfig_new/kconfiglib.py b/tools/kconfig_new/kconfiglib.py
new file mode 100644
index 00000000..527c5a55
--- /dev/null
+++ b/tools/kconfig_new/kconfiglib.py
@@ -0,0 +1,4317 @@
+# Copyright (c) 2011-2017, Ulf Magnusson
+# Modifications (c) 2018 Espressif Systems
+# SPDX-License-Identifier: ISC
+#
+# ******* IMPORTANT **********
+#
+# This is kconfiglib 2.1.0 with some modifications to match the behaviour
+# of the ESP-IDF kconfig:
+#
+# - 'source' nows uses wordexp(3) behaviour to allow source-ing multiple
+#   files at once, and to expand environment variables directly in the source
+#   command (without them having to be set as properties in the Kconfig file)
+#
+# - Added walk_menu() function and refactored to use this internally.
+#
+# - BOOL & TRISTATE items are allowed to have blank values in .config
+#   (equivalent to n, this is backwards compatibility with old IDF conf.c)
+#
+"""
+Overview
+========
+
+Kconfiglib is a Python 2/3 library for scripting and extracting information
+from Kconfig configuration systems. It can be used for the following, among
+other things:
+
+ - Programmatically get and set symbol values
+
+   allnoconfig.py and allyesconfig.py examples are provided, automatically
+   verified to produce identical output to the standard 'make allnoconfig' and
+   'make allyesconfig'.
+
+ - Read and write .config files
+
+   The generated .config files are character-for-character identical to what
+   the C implementation would generate (except for the header comment). The
+   test suite relies on this, as it compares the generated files.
+
+ - Inspect symbols
+
+   Printing a symbol gives output which could be fed back into a Kconfig parser
+   to redefine it***. The printing function (__str__()) is implemented with
+   public APIs, meaning you can fetch just whatever information you need as
+   well.
+
+   A helpful __repr__() is implemented on all objects too, also implemented
+   with public APIs.
+
+   ***Choice symbols get their parent choice as a dependency, which shows up as
+   e.g. 'prompt "choice symbol" if <choice>' when printing the symbol. This
+   could easily be worked around if 100% reparsable output is needed.
+
+ - Inspect expressions
+
+   Expressions use a simple tuple-based format that can be processed manually
+   if needed. Expression printing and evaluation functions are provided,
+   implemented with public APIs.
+
+ - Inspect the menu tree
+
+   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. See the menuconfig.py example.
+
+
+Here are some other features:
+
+ - Single-file implementation
+
+   The entire library is contained in this file.
+
+ - Runs unmodified under both Python 2 and Python 3
+
+   The code mostly uses basic Python features and has no third-party
+   dependencies. The most advanced things used are probably @property and
+   __slots__.
+
+ - Robust and highly compatible with the standard Kconfig C tools
+
+   The test suite automatically compares output from Kconfiglib and the C tools
+   by diffing the generated .config files for the real kernel Kconfig and
+   defconfig files, for all ARCHes.
+
+   This currently involves comparing the output for 36 ARCHes and 498 defconfig
+   files (or over 18000 ARCH/defconfig combinations in "obsessive" test suite
+   mode). All tests are expected to pass.
+
+ - Not horribly slow despite being a pure Python implementation
+
+   The allyesconfig.py example currently runs in about 1.6 seconds on a Core i7
+   2600K (with a warm file cache), where half a second is overhead from 'make
+   scriptconfig' (see below).
+
+   For long-running jobs, PyPy gives a big performance boost. CPython is faster
+   for short-running jobs as PyPy needs some time to warm up.
+
+ - Internals that (mostly) mirror the C implementation
+
+   While being simpler to understand.
+
+
+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. Apply it with either 'git am' or the 'patch'
+utility:
+
+  $ wget -qO- https://raw.githubusercontent.com/ulfalizer/Kconfiglib/master/makefile.patch | git am
+  $ wget -qO- https://raw.githubusercontent.com/ulfalizer/Kconfiglib/master/makefile.patch | patch -p1
+
+Warning: Not passing -p1 to patch will cause the wrong file to be patched.
+
+Please tell me if the patch does not apply. It should be trivial to apply
+manually, as it's just a block of text that needs to be inserted near the other
+*conf: targets in scripts/kconfig/Makefile.
+
+If you do not wish to install Kconfiglib via pip, the Makefile patch is set up
+so that you can also just clone Kconfiglib into the kernel root:
+
+  $ git clone git://github.com/ulfalizer/Kconfiglib.git
+  $ git am Kconfiglib/makefile.patch  (or 'patch -p1 < Kconfiglib/makefile.patch')
+
+Warning: The directory name Kconfiglib/ is significant in this case, because
+it's added to PYTHONPATH by the new targets in makefile.patch.
+
+Look further down for a motivation for the Makefile patch and for instructions
+on how you can use Kconfiglib without it.
+
+The Makefile patch adds the following targets:
+
+
+make [ARCH=<arch>] iscriptconfig
+--------------------------------
+
+This target gives an interactive Python prompt where a Kconfig instance has
+been preloaded and is available in 'kconf'. To change the Python interpreter
+used, pass PYTHONCMD=<executable> to make. The default is "python".
+
+To get a feel for the API, try evaluating and printing the symbols in
+kconf.defined_syms, and explore the MenuNode menu tree starting at
+kconf.top_node by following 'next' and 'list' pointers.
+
+The item contained in a menu node is found in MenuNode.item (note that this can
+be one of the constants MENU and COMMENT), and all symbols and choices have a
+'nodes' attribute containing their menu nodes (usually only one). Printing a
+menu node will print its item, in Kconfig format.
+
+If you want to look up a symbol by name, use the kconf.syms dictionary.
+
+
+make scriptconfig SCRIPT=<script> [SCRIPT_ARG=<arg>]
+----------------------------------------------------
+
+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
+(currently always "Kconfig" in practice), and sys.argv[2] holds the SCRIPT_ARG
+argument, if given.
+
+See the examples/ subdirectory for example scripts.
+
+
+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. The available symbols will differ depending
+on the arch as well.
+
+
+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
+
+In this example, A && B && C && D (the prompt condition) needs to be non-n 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, and any higher user value will be truncated down.
+
+'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.
+
+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.
+
+'select' works similarly to symbol visibility, but sets a lower bound on the
+value of the symbol. 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.
+
+For non-bool/tristate symbols, it only matters whether the visibility is n or
+non-n: m visibility acts 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.
+
+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 standard
+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 submenus 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).
+
+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.
+
+This organization mirrors the C implementation. MenuNode is called
+'struct menu' there, but I thought "menu" was a confusing name.
+
+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. In practice, you're unlikely to ever see a
+choice defined in more than one location. 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). Evaluating an
+expression always yields a tristate value, where n, m, and y are represented as
+0, 1, and 2, respectively.
+
+The following table should help you figure out how expressions are represented.
+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 (constant symbol))
+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.
+
+***For choice symbols, the parent Choice will appear in expressions as well,
+but it's usually invisible as the value interfaces of Symbol and Choice are
+identical. This mirrors the C implementation and makes different choice modes
+"just work".
+
+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 is 2 - A.tri_value
+
+  - The value of A = B is 2 (y) if A.str_value == B.str_value, and 0 (n)
+    otherwise. Note that str_value is used here instead of tri_value.
+
+    For constant (as well as undefined) symbols, str_value matches the name of
+    the symbol. This mirrors the C implementation and explains why
+    'depends on SYM = "foo"' above works as expected.
+
+n/m/y are automatically converted to the corresponding constant symbols
+"n"/"m"/"y" (Kconfig.n/m/y) during parsing.
+
+Kconfig.const_syms is a dictionary like Kconfig.syms but for constant symbols.
+
+If a condition is missing (e.g., <cond> when the 'if <cond>' is removed from
+'default A if <cond>'), it is actually Kconfig.y. The standard __str__()
+functions just 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.
+"""
+import errno
+import os
+import platform
+import re
+import sys
+
+# File layout:
+#
+# Public classes
+# Public functions
+# Internal functions
+# Public global constants
+# Internal global constants
+
+# Line length: 79 columns
+
+#
+# Public classes
+#
+
+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 Kconfig objects (including for different architectures) is
+    safe. Kconfiglib doesn't keep any global state.
+
+    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, indexed by name. Also
+      includes all symbols that are referenced in expressions but never
+      defined, except for constant (quoted) symbols.
+
+    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 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. 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,
+      its tri_value will be 0 (n), as expected.
+
+      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 Kconfig.defconfig_filename.
+
+    defconfig_filename:
+      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.
+
+      References to Kconfig symbols ("$FOO") in the 'default' properties of the
+      defconfig_filename symbol are are expanded before the file is looked up.
+
+      '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.
+
+      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 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
+      ("$FOO") expanded. Defaults to "Linux Kernel Configuration" (like in the
+      C tools). Can be changed with the 'mainmenu' statement (see
+      kconfig-language.txt).
+
+    srctree:
+      The value of the $srctree environment variable when the configuration was
+      loaded, or None if $srctree wasn't set. Kconfig and .config files are
+      looked up relative to $srctree if they are not found in the base path
+      (unless absolute paths are 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 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.
+
+    config_prefix:
+      The value of the $CONFIG_ environment variable when the configuration was
+      loaded. This is the prefix used (and expected) in .config files. Defaults
+      to "CONFIG_". Used in the same way in the C tools.
+
+      Like for srctree, only the value of $CONFIG_ when the configuration is
+      loaded matters.
+    """
+    __slots__ = (
+        "_choices",
+        "_print_undef_assign",
+        "_print_warnings",
+        "_set_re_match",
+        "_unset_re_match",
+        "_warn_no_prompt",
+        "config_prefix",
+        "const_syms",
+        "defconfig_list",
+        "defined_syms",
+        "m",
+        "modules",
+        "n",
+        "named_choices",
+        "srctree",
+        "syms",
+        "top_node",
+        "y",
+
+        # Parsing-related
+        "_parsing_kconfigs",
+        "_reuse_line",
+        "_file",
+        "_filename",
+        "_linenr",
+        "_filestack",
+        "_line",
+        "_tokens",
+        "_tokens_i",
+        "_has_tokens",
+    )
+
+    #
+    # Public interface
+    #
+
+    def __init__(self, filename="Kconfig", warn=True):
+        """
+        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).
+
+        filename (default: "Kconfig"):
+          The base Kconfig file. For the Linux kernel, you'll want "Kconfig"
+          from the top-level directory, as environment variables will make sure
+          the right Kconfig is included from there (arch/$SRCARCH/Kconfig as of
+          writing).
+
+          If you are using Kconfiglib via 'make scriptconfig', the filename of
+          the base base Kconfig file will be in sys.argv[1]. It's currently
+          always "Kconfig" in practice.
+
+          The $srctree environment variable is used to look up Kconfig files if
+          set. See the class documentation.
+
+        warn (default: True):
+          True if warnings related to this configuration should be printed to
+          stderr. This can be changed later with
+          Kconfig.enable/disable_warnings(). It is provided as a constructor
+          argument since warnings might be generated during parsing.
+        """
+        self.srctree = os.environ.get("srctree")
+
+        self.config_prefix = os.environ.get("CONFIG_")
+        if self.config_prefix is None:
+            self.config_prefix = "CONFIG_"
+
+        # Regular expressions for parsing .config files, with the get() method
+        # assigned directly as a small optimization (microscopic in this case,
+        # but it's consistent with the other regexes)
+        self._set_re_match = re.compile(r"{}(\w+)=(.*)"
+                                        .format(self.config_prefix)).match
+        self._unset_re_match = re.compile(r"# {}(\w+) is not set"
+                                          .format(self.config_prefix)).match
+
+        self._print_warnings = warn
+        self._print_undef_assign = False
+
+        self.syms = {}
+        self.const_syms = {}
+        self.defined_syms = []
+        self.named_choices = {}
+        # Used for quickly invalidating all choices
+        self._choices = []
+
+        for nmy in "n", "m", "y":
+            sym = Symbol()
+            sym.kconfig = self
+            sym.name = nmy
+            sym.is_constant = True
+            sym.orig_type = TRISTATE
+            sym._cached_tri_val = STR_TO_TRI[nmy]
+
+            self.const_syms[nmy] = sym
+
+        self.n = self.const_syms["n"]
+        self.m = self.const_syms["m"]
+        self.y = self.const_syms["y"]
+
+        # Make n/m/y well-formed symbols
+        for nmy in "n", "m", "y":
+            sym = self.const_syms[nmy]
+            sym.rev_dep = sym.weak_rev_dep = sym.direct_dep = self.n
+
+        # 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
+
+        # 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.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.
+        uname_sym.env_var = "<uname release>"
+        uname_sym.defaults.append(
+            (self._lookup_const_sym(platform.uname()[2]), self.y))
+        self.syms["UNAME_RELEASE"] = uname_sym
+
+        self.top_node = MenuNode()
+        self.top_node.kconfig = self
+        self.top_node.item = MENU
+        self.top_node.visibility = self.y
+        self.top_node.prompt = ("Linux Kernel Configuration", self.y)
+        self.top_node.parent = None
+        self.top_node.dep = self.y
+        self.top_node.filename = filename
+        self.top_node.linenr = 1
+
+        # Parse the Kconfig files
+
+        # These implement 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 = []
+
+        # 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
+                          self.top_node)  # prev_node
+        self.top_node.list = self.top_node.next
+        self.top_node.next = None
+
+        self._parsing_kconfigs = False
+
+        # Do various post-processing of the menu tree
+        _finalize_tree(self.top_node)
+
+        # Build Symbol._dependents for all symbols
+        self._build_dep()
+
+        self._warn_no_prompt = True
+
+    @property
+    def mainmenu_text(self):
+        """
+        See the class documentation.
+        """
+        return self._expand_syms(self.top_node.prompt[0])
+
+    @property
+    def defconfig_filename(self):
+        """
+        See the class documentation.
+        """
+        if not self.defconfig_list:
+            return None
+
+        for filename, cond in self.defconfig_list.defaults:
+            if expr_value(cond):
+                try:
+                    with self._open(self._expand_syms(filename.str_value)) as f:
+                        return f.name
+                except IOError:
+                    continue
+
+        return None
+
+    def load_config(self, filename, replace=True):
+        """
+        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 sets the user value of
+        FOO to n. The C tools work the same way.
+
+        filename:
+          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.
+        """
+        # Disable the warning about assigning to symbols without prompts. This
+        # is normal and expected within a .config file.
+        self._warn_no_prompt = False
+
+        # This stub only exists to make sure _warn_no_prompt gets reenabled
+        try:
+            self._load_config(filename, replace)
+        finally:
+            self._warn_no_prompt = True
+
+    def _load_config(self, filename, replace):
+        with self._open(filename) as f:
+            if replace:
+                # If we're replacing the configuration, keep track of which
+                # symbols and choices got set so that we can unset the rest
+                # later. This avoids invalidating everything and is faster.
+                # Another benefit is that invalidation must be rock solid for
+                # it to work, making it a good test.
+
+                for sym in self.defined_syms:
+                    sym._was_set = False
+
+                for choice in self._choices:
+                    choice._was_set = False
+
+            # Small optimizations
+            set_re_match = self._set_re_match
+            unset_re_match = self._unset_re_match
+            syms = self.syms
+
+            for linenr, line in enumerate(f, 1):
+                # The C tools ignore trailing whitespace
+                line = line.rstrip()
+
+                set_match = set_re_match(line)
+                if set_match:
+                    name, val = set_match.groups()
+                    if name not in syms:
+                        self._warn_undef_assign_load(name, val, filename,
+                                                     linenr)
+                        continue
+
+                    sym = syms[name]
+                    if not sym.nodes:
+                        self._warn_undef_assign_load(name, val, filename,
+                                                     linenr)
+                        continue
+
+                    if sym.orig_type in (BOOL, TRISTATE):
+                        # The C implementation only checks the first character
+                        # to the right of '=', for whatever reason
+                        if not ((sym.orig_type == BOOL and
+                                 val.startswith(("n", "y"))) or \
+                                (sym.orig_type == TRISTATE and
+                                 val.startswith(("n", "m", "y")))):
+                            if val != "":  # workaround for old IDF conf behaviour
+                                self._warn("'{}' is not a valid value for the {} "
+                                           "symbol {}. Assignment ignored."
+                                           .format(val, TYPE_TO_STR[sym.orig_type],
+                                                   sym.name))
+                            continue
+
+                        # We represent tristate values as 0, 1, 2
+                        val = STR_TO_TRI[val[0]]
+
+                        if sym.choice and val:
+                            # During .config loading, we infer the mode of the
+                            # choice from the kind of values that are assigned
+                            # to the choice symbols
+
+                            prev_mode = sym.choice.user_value
+                            if prev_mode is not None and prev_mode != val:
+                                self._warn("both m and y assigned to symbols "
+                                           "within the same choice",
+                                           filename, linenr)
+
+                            # Set the choice's mode
+                            sym.choice.set_value(val)
+
+                    elif sym.orig_type == 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)
+                    if not unset_match:
+                        continue
+
+                    name = unset_match.group(1)
+                    if name not in syms:
+                        self._warn_undef_assign_load(name, "n", filename,
+                                                     linenr)
+                        continue
+
+                    sym = syms[name]
+                    if sym.orig_type not in (BOOL, TRISTATE):
+                        continue
+
+                    val = 0
+
+                # Done parsing the assignment. Set the value.
+
+                if sym._was_set:
+                    # Use strings for tristate values in the warning
+                    if sym.orig_type in (BOOL, TRISTATE):
+                        display_val = TRI_TO_STR[val]
+                        display_user_val = TRI_TO_STR[sym.user_value]
+                    else:
+                        display_val = val
+                        display_user_val = sym.user_value
+
+                    self._warn('{} set more than once. Old value: "{}", new '
+                               'value: "{}".'
+                               .format(name, display_user_val, display_val),
+                               filename, linenr)
+
+                sym.set_value(val)
+
+        if replace:
+            # If we're replacing the configuration, unset the symbols that
+            # didn't get set
+
+            for sym in self.defined_syms:
+                if not sym._was_set:
+                    sym.unset_value()
+
+            for choice in self._choices:
+                if not choice._was_set:
+                    choice.unset_value()
+
+    def write_autoconf(self, filename,
+                       header="/* Generated by Kconfiglib (https://github.com/ulfalizer/Kconfiglib) */\n"):
+        r"""
+        Writes out symbol values as a C header file, matching the format used
+        by include/generated/autoconf.h in the kernel (though possibly with a
+        different ordering of the #defines, as the order in the C
+        implementation depends on the hash table implementation as of writing).
+
+        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 it enclosed in '/* */' to make it a C comment,
+          and include a final terminating newline.
+        """
+        with open(filename, "w") as f:
+
+            # Small optimizations
+            write = f.write
+            config_prefix = self.config_prefix
+
+            write(header)
+
+            def write_node(node):
+                sym = node.item
+                if not isinstance(sym, Symbol):
+                    return
+
+                # Note: _write_to_conf is determined when the value is
+                # calculated. This is a hidden function call due to
+                # property magic.
+                val = sym.str_value
+                if sym._write_to_conf:
+                    orig_type = sym.orig_type
+                    if orig_type in (BOOL, TRISTATE):
+                        if val != "n":
+                            write("#define {}{}{} 1\n"
+                                  .format(config_prefix, sym.name,
+                                          "_MODULE" if val == "m" else ""))
+
+                    elif orig_type == STRING:
+                        write('#define {}{} "{}"\n'
+                              .format(config_prefix, sym.name,
+                                          escape(val)))
+
+                    elif orig_type in (INT, HEX):
+                        if orig_type == HEX and \
+                           not val.startswith(("0x", "0X")):
+                            val = "0x" + val
+
+                        write("#define {}{} {}\n"
+                              .format(self.config_prefix, sym.name, val))
+
+                    else:
+                        _internal_error("Internal error while creating C "
+                                        'header: unknown type "{}".'
+                                        .format(sym.orig_type))
+
+            self.walk_menu(write_node)
+
+    def write_config(self, filename,
+                     header="# Generated by Kconfiglib (https://github.com/ulfalizer/Kconfiglib)\n"):
+        r"""
+        Writes out symbol values in the .config format.
+
+        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.
+        """
+        with open(filename, "w") as f:
+            # Small optimization
+            write = f.write
+
+            write(header)
+
+            def write_node(node):
+                item = node.item
+                if isinstance(item, Symbol):
+                    config_string = item.config_string
+                    if config_string:
+                        write(config_string)
+
+                elif expr_value(node.dep) and \
+                     ((item == MENU and expr_value(node.visibility)) or
+                       item == COMMENT):
+
+                    write("\n#\n# {}\n#\n".format(node.prompt[0]))
+            self.walk_menu(write_node, True)
+
+    def walk_menu(self, callback, skip_duplicates=False):
+        """
+        Walk the entire menu in order, calling callback(node)
+        for each menu node.
+
+        Used to implement write_config() & write_autoconf(), but can be
+        used to implement different types of custom processing as well.
+
+        callback:
+        Function which is called once for each node in the config tree.
+        Takes only one argument, the node.
+
+        skip_duplicates (default: False)
+        If set to True, for each item in the menu the callback will
+        only be called the first time it is encountered in the menu.
+        """
+        node = self.top_node.list
+        if not node:
+            return  # Empty configuration
+
+        seen_items = set()
+
+        while True:
+            if not (skip_duplicates and node.item in seen_items):
+                callback(node)
+                seen_items.add(node.item)
+            if node.list:
+                node = node.list
+            elif node.next:
+                node = node.next
+            else:
+                while node.parent:
+                    node = node.parent
+                    if node.next:
+                        node = node.next
+                        break
+                else:
+                    return
+
+    def eval_string(self, s):
+        """
+        Returns the tristate value of the expression 's', represented as 0, 1,
+        and 2 for 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 2 (y).
+
+        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 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.
+        """
+        # 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))  # transform_m
+
+    def unset_values(self):
+        """
+        Resets the user values of all symbols, as if Kconfig.load_config() or
+        Symbol.set_value() had never been called.
+        """
+        self._warn_no_prompt = False
+        try:
+            # 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:
+                sym.unset_value()
+
+            for choice in self._choices:
+                choice.unset_value()
+        finally:
+            self._warn_no_prompt = True
+
+    def enable_warnings(self):
+        """
+        See Kconfig.__init__().
+        """
+        self._print_warnings = True
+
+    def disable_warnings(self):
+        """
+        See Kconfig.__init__().
+        """
+        self._print_warnings = False
+
+    def enable_undef_warnings(self):
+        """
+        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
+
+    def disable_undef_warnings(self):
+        """
+        See enable_undef_assign().
+        """
+        self._print_undef_assign = False
+
+    def __repr__(self):
+        """
+        Returns a string with information about the Kconfig object when it is
+        evaluated on e.g. the interactive Python prompt.
+        """
+        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
+                'srctree "{}"'.format(self.srctree),
+            'config symbol prefix "{}"'.format(self.config_prefix),
+            "warnings " + ("enabled" if self._print_warnings else "disabled"),
+            "undef. symbol assignment warnings " +
+                ("enabled" if self._print_undef_assign else "disabled"),
+        )))
+
+    #
+    # Private methods
+    #
+
+
+    #
+    # File reading
+    #
+
+    def _open(self, filename):
+        """
+        First tries to open 'filename', then '$srctree/filename' if $srctree
+        was set when the configuration was loaded.
+        """
+        try:
+            return open(filename)
+        except IOError as e:
+            if not os.path.isabs(filename) and self.srctree is not None:
+                filename = os.path.join(self.srctree, filename)
+                try:
+                    return open(filename)
+                except IOError as e2:
+                    # This is needed for Python 3, because e2 is deleted after
+                    # the try block:
+                    #
+                    # https://docs.python.org/3/reference/compound_stmts.html#the-try-statement
+                    e = e2
+
+            raise IOError(
+                "Could not open '{}' ({}: {}). Perhaps the $srctree "
+                "environment variable (which was {}) is set incorrectly. Note "
+                "that the current value of $srctree is saved when the 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):
+        """
+        Fetches and tokenizes the next line from the current Kconfig file.
+        Returns False at EOF and True otherwise.
+        """
+        # 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
+
+        if not self._line:
+            return False
+
+        self._tokenize()
+        return True
+
+    def _next_help_line(self):
+        """
+        Used for help texts, where lines are not tokenized and no line joining
+        is done.
+        """
+        self._line = self._file.readline()
+        self._linenr += 1
+        return self._line
+
+
+    #
+    # 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_kconfigs' 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.kconfig = 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.kconfig = 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 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 the biggest hotspot
+        during parsing.
+        """
+        s = self._line
+
+        # Tricky implementation detail: While parsing a token, 'token' refers
+        # to the previous token. See _STRING_LEX for why this is needed.
+
+        # See comment at _initial_token_re_match definition
+        initial_token_match = _initial_token_re_match(s)
+        if not initial_token_match:
+            self._tokens = (None,)
+            self._tokens_i = -1
+            return
+
+        keyword = _get_keyword(initial_token_match.group(1))
+
+        if keyword == _T_HELP:
+            # Avoid junk after "help", e.g. "---", being registered as a
+            # symbol
+            self._tokens = (_T_HELP, None)
+            self._tokens_i = -1
+            return
+
+        if keyword is None:
+            self._parse_error("expected keyword as first token")
+
+        token = keyword
+        self._tokens = [keyword]
+        # The current index in the string being tokenized
+        i = initial_token_match.end()
+
+        # Main tokenization loop (for tokens past the first one)
+        while i < len(s):
+            # Test for an identifier/keyword first. This is the most common
+            # case.
+            id_keyword_match = _id_keyword_re_match(s, i)
+            if id_keyword_match:
+                # We have an identifier or keyword
+
+                # Jump past it
+                i = id_keyword_match.end()
+
+                # Check what it is. lookup_sym() will take care of allocating
+                # new symbols for us the first time we see them. Note that
+                # 'token' still refers to the previous token.
+
+                name = id_keyword_match.group(1)
+                keyword = _get_keyword(name)
+                if keyword is not None:
+                    # It's a keyword
+                    token = keyword
+
+                elif token not in _STRING_LEX:
+                    # It's a non-const symbol...
+                    if name in ("n", "m", "y"):
+                        # ...except we translate n, m, and y into the
+                        # corresponding constant symbols, like the C
+                        # implementation
+                        token = self.const_syms[name]
+                    else:
+                        token = self._lookup_sym(name)
+
+                else:
+                    # It's a case of missing quotes. For example, the
+                    # following is accepted:
+                    #
+                    #   menu unquoted_title
+                    #
+                    #   config A
+                    #       tristate unquoted_prompt
+                    #
+                    #   endmenu
+                    token = name
+
+            else:
+                # Not keyword/non-const symbol
+
+                # Note: _id_keyword_match and _initial_token_match strip
+                # trailing whitespace, making it safe to assume s[i] is the
+                # start of a token here. We manually strip trailing whitespace
+                # below as well.
+                #
+                # An old version stripped whitespace in this spot instead, but
+                # that leads to some redundancy and would cause
+                # _id_keyword_match to be tried against just "\n" fairly often
+                # (because file.readlines() keeps newlines).
+
+                c = s[i]
+                i += 1
+
+                if c in "\"'":
+                    # String literal/constant symbol
+                    if "\\" not in s:
+                        # Fast path: If the line contains no backslashes, we
+                        # can just find the matching quote.
+
+                        end = s.find(c, i)
+                        if end == -1:
+                            self._parse_error("unterminated string")
+
+                        val = s[i:end]
+                        i = end + 1
+                    else:
+                        # Slow path for lines with backslashes (very rare,
+                        # performance irrelevant)
+
+                        quote = c
+                        val = ""
+
+                        while 1:
+                            if i >= len(s):
+                                self._parse_error("unterminated string")
+
+                            c = s[i]
+                            if c == quote:
+                                break
+
+                            if c == "\\":
+                                if i + 1 >= len(s):
+                                    self._parse_error("unterminated string")
+
+                                val += s[i + 1]
+                                i += 2
+                            else:
+                                val += c
+                                i += 1
+
+                        i += 1
+
+                    # This is the only place where we don't survive with a
+                    # single token of lookback: 'option env="FOO"' does not
+                    # refer to a constant symbol named "FOO".
+                    token = val \
+                            if token in _STRING_LEX or \
+                                self._tokens[0] == _T_OPTION else \
+                            self._lookup_const_sym(val)
+
+                elif c == "&":
+                    # Invalid characters are ignored (backwards-compatible)
+                    if i >= len(s) or s[i] != "&":
+                        continue
+
+                    token = _T_AND
+                    i += 1
+
+                elif c == "|":
+                    # Invalid characters are ignored (backwards-compatible)
+                    if i >= len(s) or s[i] != "|":
+                        continue
+
+                    token = _T_OR
+                    i += 1
+
+                elif c == "!":
+                    if i < len(s) and s[i] == "=":
+                        token = _T_UNEQUAL
+                        i += 1
+                    else:
+                        token = _T_NOT
+
+                elif c == "=":
+                    token = _T_EQUAL
+
+                elif c == "(":
+                    token = _T_OPEN_PAREN
+
+                elif c == ")":
+                    token = _T_CLOSE_PAREN
+
+                elif c == "#":
+                    break
+
+                # Very rare
+                elif c == "<":
+                    if i < len(s) and s[i] == "=":
+                        token = _T_LESS_EQUAL
+                        i += 1
+                    else:
+                        token = _T_LESS
+
+                # Very rare
+                elif c == ">":
+                    if i < len(s) and s[i] == "=":
+                        token = _T_GREATER_EQUAL
+                        i += 1
+                    else:
+                        token = _T_GREATER
+
+                else:
+                    # Invalid characters are ignored (backwards-compatible)
+                    continue
+
+                # Skip trailing whitespace
+                while i < len(s) and s[i].isspace():
+                    i += 1
+
+            self._tokens.append(token)
+
+        # None-terminating token streams makes the token fetching functions
+        # simpler/faster
+        self._tokens.append(None)
+        self._tokens_i = -1
+
+    def _next_token(self):
+        self._tokens_i += 1
+        return self._tokens[self._tokens_i]
+
+    def _peek_token(self):
+        return self._tokens[self._tokens_i + 1]
+
+    def _check_token(self, token):
+        """
+        If the next token is 'token', removes it and returns True.
+        """
+        if self._tokens[self._tokens_i + 1] == token:
+            self._tokens_i += 1
+            return True
+        return False
+
+
+    #
+    # Parsing
+    #
+
+    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)
+
+    def _parse_block(self, end_token, parent, visible_if_deps, prev_node):
+        """
+        Parses a block, which is the contents of either a file or an if, menu,
+        or choice statement.
+
+        end_token:
+          The token that ends the block, e.g. _T_ENDIF ("endif") for ifs. None
+          for files.
+
+        parent:
+          The parent menu node, corresponding to e.g. a menu or Choice. Can
+          also be a Symbol, due to automatic submenu creation from
+          dependencies.
+
+        visible_if_deps:
+          'visible if' dependencies from enclosing menus. Propagated to Symbol
+          and Choice prompts.
+
+        prev_node:
+          The previous menu node. New nodes will be added after this one (by
+          modifying their 'next' pointer).
+
+          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 chaining.
+        """
+        # We might already have tokens from parsing a line to check if it's a
+        # property and discovering it isn't. self._has_tokens functions as a
+        # kind of "unget".
+        while self._has_tokens or self._next_line():
+            self._has_tokens = False
+
+            t0 = self._next_token()
+            if t0 is None:
+                continue
+
+            if t0 in (_T_CONFIG, _T_MENUCONFIG):
+                # The tokenizer allocates Symbol objects for us
+                sym = self._next_token()
+
+                node = MenuNode()
+                node.kconfig = self
+                node.item = sym
+                node.help = node.list = None
+                node.parent = parent
+                node.filename = self._filename
+                node.linenr = self._linenr
+                node.is_menuconfig = (t0 == _T_MENUCONFIG)
+
+                self._parse_properties(node, visible_if_deps)
+
+                sym.nodes.append(node)
+                self.defined_syms.append(sym)
+
+                # Tricky Python semantics: This assign prev_node.next before
+                # prev_node
+                prev_node.next = prev_node = node
+
+            elif t0 == _T_SOURCE:
+                values = _wordexp_expand(self._next_token())
+                for sourced_file in values:
+                    self._enter_file(sourced_file)
+                    prev_node = self._parse_block(None,            # end_token
+                                                  parent,
+                                                  visible_if_deps,
+                                                  prev_node)
+                    self._leave_file()
+
+            elif t0 == end_token:
+                # We have reached the end of the block. Terminate the final
+                # node and return it.
+                prev_node.next = None
+                return prev_node
+
+            elif t0 == _T_IF:
+                node = MenuNode()
+                node.item = node.prompt = None
+                node.parent = parent
+                node.filename = self._filename
+                node.linenr = self._linenr
+
+                # See similar code in _parse_properties()
+                if isinstance(parent.item, Choice):
+                    parent_dep = parent.item
+                else:
+                    parent_dep = parent.dep
+
+                node.dep = self._make_and(parent_dep, self._parse_expr(True))
+
+                self._parse_block(_T_ENDIF,
+                                  node,             # parent
+                                  visible_if_deps,
+                                  node)             # prev_node
+                node.list = node.next
+
+                prev_node.next = prev_node = node
+
+            elif t0 == _T_MENU:
+                node = MenuNode()
+                node.kconfig = self
+                node.item = MENU
+                node.visibility = self.y
+                node.parent = parent
+                node.filename = self._filename
+                node.linenr = self._linenr
+
+                prompt = self._next_token()
+                self._parse_properties(node, visible_if_deps)
+                node.prompt = (prompt, node.dep)
+
+                self._parse_block(_T_ENDMENU,
+                                  node,         # parent
+                                  self._make_and(visible_if_deps,
+                                                 node.visibility),
+                                  node)         # prev_node
+                node.list = node.next
+
+                prev_node.next = prev_node = node
+
+            elif t0 == _T_COMMENT:
+                node = MenuNode()
+                node.kconfig = self
+                node.item = COMMENT
+                node.list = None
+                node.parent = parent
+                node.filename = self._filename
+                node.linenr = self._linenr
+
+                prompt = self._next_token()
+                self._parse_properties(node, visible_if_deps)
+                node.prompt = (prompt, node.dep)
+
+                prev_node.next = prev_node = node
+
+            elif t0 == _T_CHOICE:
+                name = self._next_token()
+                if name is None:
+                    choice = Choice()
+                    self._choices.append(choice)
+                else:
+                    # Named choice
+                    choice = self.named_choices.get(name)
+                    if not choice:
+                        choice = Choice()
+                        self._choices.append(choice)
+                        choice.name = name
+                        self.named_choices[name] = choice
+
+                choice.kconfig = self
+
+                node = MenuNode()
+                node.kconfig = self
+                node.item = choice
+                node.help = None
+                node.parent = parent
+                node.filename = self._filename
+                node.linenr = self._linenr
+
+                self._parse_properties(node, visible_if_deps)
+                self._parse_block(_T_ENDCHOICE,
+                                  node,             # parent
+                                  visible_if_deps,
+                                  node)             # prev_node
+                node.list = node.next
+
+                choice.nodes.append(node)
+
+                prev_node.next = prev_node = node
+
+            elif t0 == _T_MAINMENU:
+                self.top_node.prompt = (self._next_token(), self.y)
+                self.top_node.filename = self._filename
+                self.top_node.linenr = self._linenr
+
+            else:
+                self._parse_error("unrecognized construct")
+
+        # End of file reached. Terminate the final node and return it.
+
+        if end_token is not None:
+            raise KconfigSyntaxError("Unexpected end of file " +
+                                     self._filename)
+
+        prev_node.next = None
+        return prev_node
+
+    def _parse_cond(self):
+        """
+        Parses an optional 'if <expr>' construct and returns the parsed <expr>,
+        or self.y if the next token is not _T_IF
+        """
+        return self._parse_expr(True) if self._check_token(_T_IF) else self.y
+
+    def _parse_properties(self, node, visible_if_deps):
+        """
+        Parses properties for symbols, menus, choices, and comments. Also takes
+        care of propagating dependencies from the menu node to the properties
+        of the item (this mirrors the C tools, though they do it after
+        parsing).
+
+        node:
+          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.
+        """
+        # New properties encountered at this location. A local 'depends on'
+        # only applies to these, in case a symbol is defined in multiple
+        # locations.
+        prompt = None
+        defaults = []
+        selects = []
+        implies = []
+        ranges = []
+
+        # Menu node dependencies from 'depends on'. Will get propagated to the
+        # properties above.
+        node.dep = self.y
+
+        while self._next_line():
+            t0 = self._next_token()
+            if t0 is None:
+                continue
+
+            if t0 in _TYPE_TOKENS:
+                node.item.orig_type = _TOKEN_TO_TYPE[t0]
+
+                if self._peek_token() is not None:
+                    prompt = (self._next_token(), self._parse_cond())
+
+            elif t0 == _T_DEPENDS:
+                if not self._check_token(_T_ON):
+                    self._parse_error('expected "on" after "depends"')
+
+                node.dep = self._make_and(node.dep, self._parse_expr(True))
+
+            elif t0 == _T_HELP:
+                # Find first non-blank (not all-space) line and get its
+                # indentation
+
+                while 1:
+                    line = self._next_help_line()
+                    if not line or not line.isspace():
+                        break
+
+                if not line:
+                    node.help = ""
+                    break
+
+                indent = _indentation(line)
+                if indent == 0:
+                    # If the first non-empty lines has zero indent, there is no
+                    # help text
+                    node.help = ""
+                    self._reuse_line = True  # "Unget" the line
+                    break
+
+                # The help text goes on till the first non-empty line with less
+                # indent
+
+                help_lines = [_deindent(line, indent).rstrip()]
+                while 1:
+                    line = self._next_help_line()
+
+                    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:
+                    break
+
+                self._reuse_line = True  # "Unget" the line
+
+            elif t0 == _T_SELECT:
+                if not isinstance(node.item, Symbol):
+                    self._parse_error("only symbols can select")
+
+                selects.append((self._next_token(), self._parse_cond()))
+
+            elif t0 == _T_IMPLY:
+                if not isinstance(node.item, Symbol):
+                    self._parse_error("only symbols can imply")
+
+                implies.append((self._next_token(), self._parse_cond()))
+
+            elif t0 == _T_DEFAULT:
+                defaults.append((self._parse_expr(False), self._parse_cond()))
+
+            elif t0 in (_T_DEF_BOOL, _T_DEF_TRISTATE):
+                node.item.orig_type = _TOKEN_TO_TYPE[t0]
+                defaults.append((self._parse_expr(False), self._parse_cond()))
+
+            elif t0 == _T_PROMPT:
+                # 'prompt' properties override each other within a single
+                # definition of a symbol, but additional prompts can be added
+                # by defining the symbol multiple times
+                prompt = (self._next_token(), self._parse_cond())
+
+            elif t0 == _T_RANGE:
+                ranges.append((self._next_token(),
+                               self._next_token(),
+                               self._parse_cond()))
+
+            elif t0 == _T_OPTION:
+                if self._check_token(_T_ENV):
+                    if not self._check_token(_T_EQUAL):
+                        self._parse_error("expected '=' after 'env'")
+
+                    env_var = self._next_token()
+                    node.item.env_var = env_var
+
+                    if env_var not in os.environ:
+                        self._warn("'option env=\"{0}\"' on symbol {1} has "
+                                   "no effect, because the environment "
+                                   "variable {0} is not set"
+                                   .format(env_var, node.item.name),
+                                   self._filename, self._linenr)
+                    else:
+                        defaults.append(
+                            (self._lookup_const_sym(os.environ[env_var]),
+                             self.y))
+
+                elif self._check_token(_T_DEFCONFIG_LIST):
+                    if not self.defconfig_list:
+                        self.defconfig_list = node.item
+                    else:
+                        self._warn("'option defconfig_list' set on multiple "
+                                   "symbols ({0} and {1}). Only {0} will be "
+                                   "used.".format(self.defconfig_list.name,
+                                                  node.item.name),
+                                   self._filename, self._linenr)
+
+                elif self._check_token(_T_MODULES):
+                    # To reduce warning spam, only warn if 'option modules' is
+                    # set on some symbol that isn't MODULES, which should be
+                    # safe. I haven't run into any projects that make use
+                    # modules besides the kernel yet, and there it's likely to
+                    # keep being called "MODULES".
+                    if node.item is not self.modules:
+                        self._warn("the 'modules' option is not 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.",
+                                   self._filename, self._linenr)
+
+                elif self._check_token(_T_ALLNOCONFIG_Y):
+                    if not isinstance(node.item, Symbol):
+                        self._parse_error("the 'allnoconfig_y' option is only "
+                                          "valid for symbols")
+
+                    node.item.is_allnoconfig_y = True
+
+                else:
+                    self._parse_error("unrecognized option")
+
+            elif t0 == _T_VISIBLE:
+                if not self._check_token(_T_IF):
+                    self._parse_error('expected "if" after "visible"')
+
+                node.visibility = \
+                    self._make_and(node.visibility, self._parse_expr(True))
+
+            elif t0 == _T_OPTIONAL:
+                if not isinstance(node.item, Choice):
+                    self._parse_error('"optional" is only valid for choices')
+
+                node.item.is_optional = True
+
+            else:
+                self._tokens_i = -1
+                # Reuse the tokens for the non-property line later
+                self._has_tokens = True
+                break
+
+        # Done parsing properties. Now add the new
+        # prompts/defaults/selects/implies/ranges properties, with dependencies
+        # from node.dep propagated.
+
+        # First propagate parent dependencies to node.dep
+
+        # If the parent node holds a Choice, we use the Choice itself as the
+        # parent dependency. This matches the C implementation, and makes sense
+        # as the value (mode) of the choice limits the visibility of the
+        # contained choice symbols. Due to the similar interface, Choice works
+        # as a drop-in replacement for Symbol here.
+        if isinstance(node.parent.item, Choice):
+            node.dep = self._make_and(node.dep, node.parent.item)
+        else:
+            node.dep = self._make_and(node.dep, node.parent.dep)
+
+        if isinstance(node.item, (Symbol, Choice)):
+            if isinstance(node.item, Symbol):
+                # See the class documentation
+                node.item.direct_dep = \
+                    self._make_or(node.item.direct_dep, node.dep)
+
+            # Set the prompt, with dependencies propagated
+            if prompt:
+                node.prompt = (prompt[0],
+                               self._make_and(self._make_and(prompt[1],
+                                                             node.dep),
+                                              visible_if_deps))
+            else:
+                node.prompt = None
+
+            # Add the new defaults, with dependencies propagated
+            for val_expr, cond in defaults:
+                node.item.defaults.append(
+                    (val_expr, self._make_and(cond, node.dep)))
+
+            # Add the new ranges, with dependencies propagated
+            for low, high, cond in ranges:
+                node.item.ranges.append(
+                    (low, high, self._make_and(cond, node.dep)))
+
+            # Handle selects
+            for target, cond in selects:
+                # Only stored for inspection. Not used during evaluation.
+                node.item.selects.append(
+                    (target, self._make_and(cond, node.dep)))
+
+                # Modify the dependencies of the selected symbol
+                target.rev_dep = \
+                    self._make_or(target.rev_dep,
+                                  self._make_and(node.item,
+                                                 self._make_and(cond,
+                                                                node.dep)))
+
+            # Handle implies
+            for target, cond in implies:
+                # Only stored for inspection. Not used during evaluation.
+                node.item.implies.append(
+                    (target, self._make_and(cond, node.dep)))
+
+                # Modify the dependencies of the implied symbol
+                target.weak_rev_dep = \
+                    self._make_or(target.weak_rev_dep,
+                                  self._make_and(node.item,
+                                                 self._make_and(cond,
+                                                                node.dep)))
+
+    def _parse_expr(self, transform_m):
+        """
+        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
+          Kconfig.eval_string() documentation.
+        """
+        # Grammar:
+        #
+        #   expr:     and_expr ['||' expr]
+        #   and_expr: factor ['&&' and_expr]
+        #   factor:   <symbol> ['='/'!='/'<'/... <symbol>]
+        #             '!' factor
+        #             '(' expr ')'
+        #
+        # It helps to think of the 'expr: and_expr' case as a single-operand OR
+        # (no ||), and of the 'and_expr: factor' case as a single-operand AND
+        # (no &&). Parsing code is always a bit tricky.
+
+        # Mind dump: parse_factor() and two nested loops for OR and AND would
+        # work as well. The straightforward implementation there gives a
+        # (op, (op, (op, A, B), C), D) parse for A op B op C op D. Representing
+        # expressions as (op, [list of operands]) instead goes nicely with that
+        # version, but is wasteful for short expressions and complicates
+        # expression evaluation and other code that works on expressions (more
+        # complicated code likely offsets any performance gain from less
+        # recursion too). If we also try to optimize the list representation by
+        # merging lists when possible (e.g. when ANDing two AND expressions),
+        # we end up allocating a ton of lists instead of reusing expressions,
+        # which is bad.
+
+        and_expr = self._parse_and_expr(transform_m)
+
+        # Return 'and_expr' directly if we have a "single-operand" OR.
+        # Otherwise, parse the expression on the right and make an OR node.
+        # This turns A || B || C || D into (OR, A, (OR, B, (OR, C, D))).
+        return and_expr \
+               if not self._check_token(_T_OR) else \
+               (OR, and_expr, self._parse_expr(transform_m))
+
+    def _parse_and_expr(self, transform_m):
+        factor = self._parse_factor(transform_m)
+
+        # Return 'factor' directly if we have a "single-operand" AND.
+        # Otherwise, parse the right operand and make an AND node. This turns
+        # A && B && C && D into (AND, A, (AND, B, (AND, C, D))).
+        return factor \
+               if not self._check_token(_T_AND) else \
+               (AND, factor, self._parse_and_expr(transform_m))
+
+    def _parse_factor(self, transform_m):
+        token = self._next_token()
+
+        if isinstance(token, Symbol):
+            # Plain symbol or relation
+
+            next_token = self._peek_token()
+            if next_token not in _TOKEN_TO_REL:
+                # Plain symbol
+
+                # For conditional expressions ('depends on <expr>',
+                # '... if <expr>', etc.), m is rewritten to m && MODULES.
+                if transform_m and token is self.m:
+                    return (AND, self.m, self.modules)
+
+                return token
+
+            # Relation
+            return (_TOKEN_TO_REL[self._next_token()], token,
+                    self._next_token())
+
+        if token == _T_NOT:
+            return (NOT, self._parse_factor(transform_m))
+
+        if token == _T_OPEN_PAREN:
+            expr_parse = self._parse_expr(transform_m)
+            if not self._check_token(_T_CLOSE_PAREN):
+                self._parse_error("missing end parenthesis")
+
+            return expr_parse
+
+        self._parse_error("malformed expression")
+
+    #
+    # Caching and invalidation
+    #
+
+    def _build_dep(self):
+        """
+        Populates the Symbol/Choice._dependents sets, which contain all other
+        items (symbols and choices) that immediately depend on the item in the
+        sense that changing the value of the item might affect the value of the
+        dependent items. 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.
+        """
+        # Only calculate _dependents for defined symbols. Constant and
+        # undefined symbols could theoretically be selected/implied, but it
+        # wouldn't change their value, so it's not a true dependency.
+        for sym in self.defined_syms:
+            # Symbols depend on the following:
+
+            # The prompt conditions
+            for node in sym.nodes:
+                if node.prompt:
+                    _make_depend_on(sym, node.prompt[1])
+
+            # The default values and their conditions
+            for value, cond in sym.defaults:
+                _make_depend_on(sym, value)
+                _make_depend_on(sym, cond)
+
+            # The reverse and weak reverse dependencies
+            _make_depend_on(sym, sym.rev_dep)
+            _make_depend_on(sym, sym.weak_rev_dep)
+
+            # The ranges along with their conditions
+            for low, high, cond in sym.ranges:
+                _make_depend_on(sym, low)
+                _make_depend_on(sym, high)
+                _make_depend_on(sym, cond)
+
+            # The direct dependencies. This is usually redundant, as the direct
+            # dependencies get propagated to properties, but it's needed to get
+            # invalidation solid for 'imply', which only checks the direct
+            # dependencies (even if there are no properties to propagate it
+            # to).
+            _make_depend_on(sym, sym.direct_dep)
+
+            # In addition to the above, choice symbols depend on the choice
+            # they're in, but that's handled automatically since the Choice is
+            # propagated to the conditions of the properties before
+            # _build_dep() runs.
+
+        for choice in self._choices:
+            # Choices depend on the following:
+
+            # The prompt conditions
+            for node in choice.nodes:
+                if node.prompt:
+                    _make_depend_on(choice, node.prompt[1])
+
+            # The default symbol conditions
+            for _, cond in choice.defaults:
+                _make_depend_on(choice, cond)
+
+            # The choice symbols themselves, because the y mode selection might
+            # change if a choice symbol's visibility changes
+            for sym in choice.syms:
+                # the default selection depends on the symbols
+                sym._dependents.add(choice)
+
+    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()
+
+
+    #
+    # Misc.
+    #
+
+    def _expand_syms(self, s):
+        """
+        Expands $-references to symbols in 's' to symbol values, or to the
+        empty string for undefined symbols.
+        """
+        while 1:
+            sym_ref_match = _sym_ref_re_search(s)
+            if not sym_ref_match:
+                return s
+
+            sym = self.syms.get(sym_ref_match.group(1))
+
+            s = s[:sym_ref_match.start()] + \
+                (sym.str_value if sym else "") + \
+                s[sym_ref_match.end():]
+
+    def _parse_error(self, msg):
+        if self._filename is None:
+            loc = ""
+        else:
+            loc = "{}:{}: ".format(self._filename, self._linenr)
+
+        raise KconfigSyntaxError(
+            "{}Couldn't parse '{}': {}".format(loc, self._line.rstrip(), msg))
+
+    def _warn(self, msg, filename=None, linenr=None):
+        """
+        For printing general warnings.
+        """
+        if self._print_warnings:
+            _stderr_msg("warning: " + msg, filename, linenr)
+
+    def _warn_undef_assign(self, msg, filename=None, linenr=None):
+        """
+        See the class documentation.
+        """
+        if self._print_undef_assign:
+            _stderr_msg("warning: " + msg, filename, linenr)
+
+    def _warn_undef_assign_load(self, name, val, filename, linenr):
+        """
+        Special version for load_config().
+        """
+        self._warn_undef_assign(
+            'attempt to assign the value "{}" to the undefined symbol {}' \
+            .format(val, name), filename, linenr)
+
+
+class Symbol(object):
+    """
+    Represents a configuration symbol:
+
+      (menu)config FOO
+          ...
+
+    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, help texts, and locations are stored in the Symbol's
+    MenuNode(s) rather than in the Symbol itself. Check the MenuNode class and
+    the Symbol.nodes attribute. This organization 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, (non-special) constant symbols, and
+      symbols defined without a 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:
+      The value of the symbol as a string. Gives the 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.)
+
+      Gotcha: For int/hex symbols, the exact format of the value must often be
+      preserved (e.g., when writing a .config file), hence why you can't get it
+      directly as an int. Do int(int_sym.str_value) or
+      int(hex_sym.str_value, 16) to get the integer value.
+
+    tri_value:
+      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 tuple containing the tristate user values that can currently be
+      assigned to the symbol (that would 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 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 m or y through a select, perhaps in combination with the
+      visibility. menuconfig represents this as -M- and -*-, respectively.
+
+      For string/hex/int symbols, check if Symbol.visibility is non-0 (non-n)
+      instead to determine if the value can be changed.
+
+      Some handy 'assignable' idioms:
+
+        # Is 'sym' an assignable (visible) bool/tristate symbol?
+        if sym.assignable:
+            # What's the highest value it can be assigned? [-1] in Python
+            # gives the last element.
+            sym_high = sym.assignable[-1]
+
+            # The lowest?
+            sym_low = sym.assignable[0]
+
+            # Can the symbol be set to at least m?
+            if sym.assignable[-1] >= 1:
+                ...
+
+        # Can the symbol be set to m?
+        if 1 in sym.assignable:
+            ...
+
+    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_value:
+      The user value of the symbol. None if no user value has been assigned
+      (via Kconfig.load_config() or Symbol.set_value()).
+
+      Holds 0, 1, or 2 for bool/tristate symbols, and a string for the other
+      symbol types.
+
+      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 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 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' 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.kconfig.y.
+
+      Note that 'depends on' and parent dependencies are propagated to
+      'default' conditions.
+
+    selects:
+      List of (symbol, cond) tuples for the symbol's 'select' properties. For
+      example, 'select A if B && C' is represented as (A, (AND, B, C)). If no
+      condition was given, 'cond' is self.kconfig.y.
+
+      Note that 'depends on' and parent dependencies are propagated to 'select'
+      conditions.
+
+    implies:
+      Like 'selects', for imply.
+
+    ranges:
+      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: 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 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)).
+
+    weak_rev_dep:
+      Like rev_dep, for imply.
+
+    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. 'depends on' and
+      parent dependencies are automatically propagated to the conditions of
+      properties, so normally it's redundant to check the direct dependencies.
+
+    env_var:
+      If the Symbol has an 'option env="FOO"' option, this contains the name
+      ("FOO") of the environment variable. None for symbols that aren't set
+      from the environment.
+
+      'option env="FOO"' acts as a 'default' property whose value is the value
+      of $FOO.
+
+      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, 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 (except when printing symbols), but can be checked by
+      scripts.
+
+    is_constant:
+      True if the symbol is a constant (quoted) symbol.
+
+    kconfig:
+      The Kconfig instance this symbol is from.
+    """
+    __slots__ = (
+        "_cached_assignable",
+        "_cached_str_val",
+        "_cached_tri_val",
+        "_cached_vis",
+        "_dependents",
+        "_was_set",
+        "_write_to_conf",
+        "choice",
+        "defaults",
+        "direct_dep",
+        "env_var",
+        "implies",
+        "is_allnoconfig_y",
+        "is_constant",
+        "kconfig",
+        "name",
+        "nodes",
+        "orig_type",
+        "ranges",
+        "rev_dep",
+        "selects",
+        "user_value",
+        "weak_rev_dep",
+    )
+
+    #
+    # Public interface
+    #
+
+    @property
+    def type(self):
+        """
+        See the class documentation.
+        """
+        if self.orig_type == TRISTATE and \
+           ((self.choice and self.choice.tri_value == 2) or
+            not self.kconfig.modules.tri_value):
+            return BOOL
+
+        return self.orig_type
+
+    @property
+    def str_value(self):
+        """
+        See the class documentation.
+        """
+        if self._cached_str_val is not None:
+            return self._cached_str_val
+
+        if self.orig_type in (BOOL, TRISTATE):
+            # Also calculates the visibility, so invalidation safe
+            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.orig_type == UNKNOWN:
+            self._cached_str_val = self.name
+            return self.name
+
+        val = ""
+        # Warning: See Symbol._rec_invalidate(), and note that this is a hidden
+        # function call (property magic)
+        vis = self.visibility
+
+        self._write_to_conf = (vis != 0)
+
+        if self.orig_type in (INT, HEX):
+            # The C implementation checks the user value against the range in a
+            # separate code path (post-processing after loading a .config).
+            # Checking all values here instead makes more sense for us. It
+            # requires that we check for a range first.
+
+            base = _TYPE_TO_BASE[self.orig_type]
+
+            # Check if a range is in effect
+            for low_expr, high_expr, cond in self.ranges:
+                if expr_value(cond):
+                    has_active_range = True
+
+                    # The zeros are from the C implementation running strtoll()
+                    # on empty strings
+                    low = int(low_expr.str_value, base) if \
+                      _is_base_n(low_expr.str_value, base) else 0
+                    high = int(high_expr.str_value, base) if \
+                      _is_base_n(high_expr.str_value, base) else 0
+
+                    break
+            else:
+                has_active_range = False
+
+            if vis and self.user_value is not None and \
+               _is_base_n(self.user_value, base) and \
+               (not has_active_range or
+                low <= int(self.user_value, base) <= high):
+
+                # If the user value is well-formed and satisfies range
+                # contraints, it is stored in exactly the same form as
+                # specified in the assignment (with or without "0x", etc.)
+                val = self.user_value
+
+            else:
+                # No user value or invalid user value. Look at defaults.
+
+                for val_expr, cond in self.defaults:
+                    if expr_value(cond):
+                        self._write_to_conf = True
+
+                        val = val_expr.str_value
+
+                        if _is_base_n(val, base):
+                            val_num = int(val, base)
+                        else:
+                            val_num = 0  # strtoll() on empty string
+
+                        break
+                else:
+                    val_num = 0  # strtoll() on empty string
+
+                # This clamping procedure runs even if there's no default
+                if has_active_range:
+                    clamp = None
+                    if val_num < low:
+                        clamp = low
+                    elif val_num > high:
+                        clamp = high
+
+                    if clamp is not None:
+                        # The value is rewritten to a standard form if it is
+                        # clamped
+                        val = str(clamp) \
+                              if self.orig_type == INT else \
+                              hex(clamp)
+
+        elif self.orig_type == STRING:
+            if vis and self.user_value is not None:
+                # If the symbol is visible and has a user value, use that
+                val = self.user_value
+            else:
+                # Otherwise, look at defaults
+                for val_expr, cond in self.defaults:
+                    if expr_value(cond):
+                        self._write_to_conf = True
+                        val = val_expr.str_value
+                        break
+
+        # Corresponds to SYMBOL_AUTO in the C implementation
+        if self.env_var is not None:
+            self._write_to_conf = False
+
+        self._cached_str_val = val
+        return val
+
+    @property
+    def tri_value(self):
+        """
+        See the class documentation.
+        """
+        if self._cached_tri_val is not None:
+            return self._cached_tri_val
+
+        if self.orig_type not in (BOOL, TRISTATE):
+            self._cached_tri_val = 0
+            return self._cached_tri_val
+
+        val = 0
+        # Warning: See Symbol._rec_invalidate(), and note that this is a hidden
+        # function call (property magic)
+        vis = self.visibility
+        self._write_to_conf = (vis != 0)
+
+        if not self.choice:
+            # Non-choice symbol
+
+            if vis and self.user_value is not None:
+                # If the symbol is visible and has a user value, use that
+                val = min(self.user_value, vis)
+
+            else:
+                # Otherwise, look at defaults and weak reverse dependencies
+                # (implies)
+
+                for default, cond in self.defaults:
+                    cond_val = expr_value(cond)
+                    if cond_val:
+                        val = min(expr_value(default), cond_val)
+                        self._write_to_conf = True
+                        break
+
+                # Weak reverse dependencies are only considered if our
+                # direct dependencies are met
+                weak_rev_dep_val = expr_value(self.weak_rev_dep)
+                if weak_rev_dep_val and expr_value(self.direct_dep):
+                    val = max(weak_rev_dep_val, val)
+                    self._write_to_conf = True
+
+            # Reverse (select-related) dependencies take precedence
+            rev_dep_val = expr_value(self.rev_dep)
+            if rev_dep_val:
+                val = max(rev_dep_val, val)
+                self._write_to_conf = True
+
+            # 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
+
+        elif vis == 2:
+            # Visible choice symbol in y-mode choice. The choice mode limits
+            # the visibility of choice symbols, so it's sufficient to just
+            # check the visibility of the choice symbols themselves.
+            val = 2 if self.choice.selection is self else 0
+
+        elif vis and self.user_value:
+            # Visible choice symbol in m-mode choice, with set non-0 user value
+            val = 1
+
+        self._cached_tri_val = val
+        return val
+
+    @property
+    def assignable(self):
+        """
+        See the class documentation.
+        """
+        if self._cached_assignable is not None:
+            return self._cached_assignable
+
+        self._cached_assignable = self._get_assignable()
+        return self._cached_assignable
+
+    @property
+    def visibility(self):
+        """
+        See the class documentation.
+        """
+        if self._cached_vis is not None:
+            return self._cached_vis
+
+        self._cached_vis = _get_visibility(self)
+        return self._cached_vis
+
+    @property
+    def config_string(self):
+        """
+        See the class documentation.
+        """
+        # Note: _write_to_conf is determined when the value is calculated. This
+        # is a hidden function call due to property magic.
+        val = self.str_value
+        if not self._write_to_conf:
+            return None
+
+        if self.orig_type in (BOOL, TRISTATE):
+            return "{}{}={}\n" \
+                   .format(self.kconfig.config_prefix, self.name, val) \
+                   if val != "n" else \
+                   "# {}{} is not set\n" \
+                   .format(self.kconfig.config_prefix, self.name)
+
+        if self.orig_type in (INT, HEX):
+            return "{}{}={}\n" \
+                   .format(self.kconfig.config_prefix, self.name, val)
+
+        if self.orig_type == STRING:
+            # Escape \ and "
+            return '{}{}="{}"\n' \
+                   .format(self.kconfig.config_prefix, self.name, escape(val))
+
+        _internal_error("Internal error while creating .config: unknown "
+                        '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. 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).
+
+        Setting a choice symbol to 2 (y) only updates Choice.user_selection on
+        the parent choice and not Symbol.user_value itself. This gives the
+        expected behavior when a choice is switched between different modes.
+        Choice.user_selection is considered when the choice is in y mode (the
+        "normal" mode).
+
+        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. For bool and tristate symbols,
+          pass 0, 1, 2 for n, m, and y, respectively. For other symbol types,
+          pass a string.
+
+          Values that are invalid for the type (such as "foo" or 1 (m) for a
+          BOOL) are ignored and won't be stored in Symbol.user_str/tri_value.
+          Kconfiglib will print a warning by default for invalid assignments,
+          and set_value() will return False.
+
+        Returns True if the value is valid for the type of the symbol, and
+        False otherwise. This only looks at the form of the value. For BOOL and
+        TRISTATE symbols, check the Symbol.assignable attribute to see what
+        values are currently in range and would actually be reflected in the
+        value of the symbol. For other symbol types, check whether the
+        visibility is non-n.
+        """
+        if value == self.user_value:
+            # We know the value must be valid if it was successfully set
+            # previously
+            self._was_set = True
+            return True
+
+        # Check if the value is valid for our 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)
+                                            and int(value, 16) >= 0)):
+
+            # Display tristate values as n, m, y in the warning
+            warning = "the value {} is invalid for {}, which has type {}" \
+                      .format(TRI_TO_STR[value] if value in (0, 1, 2) else
+                                 "'{}'".format(value),
+                              self.name, TYPE_TO_STR[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.kconfig._warn(warning)
+
+            return False
+
+        if self.env_var is not None:
+            self.kconfig._warn("ignored attempt to assign user value to "
+                               "{}, which gets its value from the environment"
+                               .format(self.name))
+            return False
+
+        if self.choice and value == 2:
+            # Remember this as a choice selection only. Makes switching back
+            # and forth between choice modes work as expected, and makes the
+            # check for whether the user value is the same as before above
+            # safe.
+            self.choice.user_selection = self
+            self.choice._was_set = True
+            if self._is_user_assignable():
+                self.choice._rec_invalidate()
+        else:
+            self.user_value = value
+            self._was_set = True
+            if self._is_user_assignable():
+                self._rec_invalidate()
+
+        return True
+
+    def unset_value(self):
+        """
+        Resets the user value of the symbol, as if the symbol had never gotten
+        a user value via Kconfig.load_config() or Symbol.set_value().
+        """
+        if self.user_value is not None:
+            self.user_value = None
+            if self._is_user_assignable():
+                self._rec_invalidate()
+
+    def __repr__(self):
+        """
+        Returns a string with information about the symbol (including its name,
+        value, visibility, and location(s)) when it is evaluated on e.g. the
+        interactive Python prompt.
+        """
+        fields = []
+
+        fields.append("symbol " + self.name)
+        fields.append(TYPE_TO_STR[self.type])
+
+        for node in self.nodes:
+            if node.prompt:
+                fields.append('"{}"'.format(node.prompt[0]))
+
+        # Only add quotes for non-bool/tristate symbols
+        fields.append("value " +
+                      (self.str_value
+                       if self.orig_type in (BOOL, TRISTATE) else
+                       '"{}"'.format(self.str_value)))
+
+        if not self.is_constant:
+            # These aren't helpful to show for constant symbols
+
+            if self.user_value is not None:
+                # Only add quotes for non-bool/tristate symbols
+                fields.append("user value " +
+                              (TRI_TO_STR[self.user_value]
+                               if self.orig_type in (BOOL, TRISTATE) else
+                               '"{}"'.format(self.user_value)))
+
+            fields.append("visibility " + TRI_TO_STR[self.visibility])
+
+            if self.choice:
+                fields.append("choice symbol")
+
+            if self.is_allnoconfig_y:
+                fields.append("allnoconfig_y")
+
+            if self is self.kconfig.defconfig_list:
+                fields.append("is the defconfig_list symbol")
+
+            if self.env_var is not None:
+                fields.append("from environment variable " + self.env_var)
+
+            if self is self.kconfig.modules:
+                fields.append("is the modules symbol")
+
+            fields.append("direct deps " +
+                          TRI_TO_STR[expr_value(self.direct_dep)])
+
+        if self.nodes:
+            for node in self.nodes:
+                fields.append("{}:{}".format(node.filename, node.linenr))
+        else:
+            if self.is_constant:
+                fields.append("constant")
+            else:
+                fields.append("undefined")
+
+        return "<{}>".format(", ".join(fields))
+
+    def __str__(self):
+        """
+        Returns a string representation of the symbol when it is printed,
+        matching the Kconfig format. Prompts and help texts are included,
+        though they really belong to the symbol's menu nodes rather than the
+        symbol itself.
+
+        The output is designed so that feeding it back to a Kconfig parser
+        redefines the symbol as is. This also works for symbols defined in
+        multiple locations, where all the definitions are output. See the
+        module documentation for a small gotcha related to choice symbols.
+
+        An empty string is returned for undefined and constant symbols.
+        """
+        return _sym_choice_str(self)
+
+    #
+    # Private methods
+    #
+
+    def __init__(self):
+        """
+        Symbol constructor -- not intended to be called directly by Kconfiglib
+        clients.
+        """
+        # These attributes are always set on the instance from outside and
+        # don't need defaults:
+        #   kconfig
+        #   direct_dep
+        #   is_constant
+        #   name
+        #   rev_dep
+        #   weak_rev_dep
+
+        self.orig_type = UNKNOWN
+        self.defaults = []
+        self.selects = []
+        self.implies = []
+        self.ranges = []
+
+        self.nodes = []
+
+        self.user_value = \
+        self.choice = \
+        self.env_var = \
+        self._cached_str_val = self._cached_tri_val = self._cached_vis = \
+        self._cached_assignable = None
+
+        # _write_to_conf is calculated along with the value. If True, the
+        # Symbol gets a .config entry.
+
+        self.is_allnoconfig_y = \
+        self._was_set = \
+        self._write_to_conf = False
+
+        # See Kconfig._build_dep()
+        self._dependents = set()
+
+    def _get_assignable(self):
+        """
+        Worker function for the 'assignable' attribute.
+        """
+        if self.orig_type not in (BOOL, TRISTATE):
+            return ()
+
+        # Warning: See Symbol._rec_invalidate(), and note that this is a hidden
+        # function call (property magic)
+        vis = self.visibility
+
+        if not vis:
+            return ()
+
+        rev_dep_val = expr_value(self.rev_dep)
+
+        if vis == 2:
+            if self.choice:
+                return (2,)
+
+            if not rev_dep_val:
+                if self.type == BOOL or expr_value(self.weak_rev_dep) == 2:
+                    return (0, 2)
+                return (0, 1, 2)
+
+            if rev_dep_val == 2:
+                return (2,)
+
+            # rev_dep_val == 1
+
+            if self.type == BOOL or expr_value(self.weak_rev_dep) == 2:
+                return (2,)
+            return (1, 2)
+
+        # vis == 1
+
+        # Must be a tristate here, because bool m visibility gets promoted to y
+
+        if not rev_dep_val:
+            return (0, 1) if expr_value(self.weak_rev_dep) != 2 else (0, 2)
+
+        if rev_dep_val == 2:
+            return (2,)
+
+        # vis == rev_dep_val == 1
+
+        return (1,)
+
+    def _is_user_assignable(self):
+        """
+        Returns True if the symbol has a prompt, meaning a user value might
+        have an effect on it. Used as an optimization to skip invalidation when
+        promptless symbols are assigned to (given a user value).
+
+        Prints a warning if the symbol has no prompt. In some contexts (e.g.
+        when loading a .config files) assignments to promptless symbols are
+        normal and expected, so the warning can be disabled.
+        """
+        for node in self.nodes:
+            if node.prompt:
+                return True
+
+        if self.kconfig._warn_no_prompt:
+            self.kconfig._warn(self.name + " has no prompt, meaning user "
+                               "values have no effect on it")
+        return False
+
+    def _invalidate(self):
+        """
+        Marks the symbol as needing to be recalculated.
+        """
+        self._cached_str_val = self._cached_tri_val = self._cached_vis = \
+            self._cached_assignable = None
+
+    def _rec_invalidate(self):
+        """
+        Invalidates the symbol and all items that (possibly) depend on it.
+        """
+        if self is self.kconfig.modules:
+            # Invalidating MODULES has wide-ranging effects
+            self.kconfig._invalidate_all()
+        else:
+            self._invalidate()
+
+            for item in self._dependents:
+                # _cached_vis doubles as a flag that tells us whether 'item'
+                # has cached values, because it's calculated as a side effect
+                # of calculating all other (non-constant) cached values.
+                #
+                # If item._cached_vis is None, it means there can't be cached
+                # values on other items that depend on 'item', because if there
+                # were, some value on 'item' would have been calculated and
+                # item._cached_vis set as a side effect. It's therefore safe to
+                # stop the invalidation at symbols with _cached_vis None.
+                #
+                # This approach massively speeds up scripts that set a lot of
+                # values, vs simply invalidating all possibly dependent symbols
+                # (even when you already have a list of all the dependent
+                # symbols, because some symbols get huge dependency trees).
+                #
+                # This gracefully handles dependency loops too, which is nice
+                # for choices, where the choice depends on the choice symbols
+                # and vice versa.
+                if item._cached_vis is not None:
+                    item._rec_invalidate()
+
+class Choice(object):
+    """
+    Represents a choice statement:
+
+      choice
+          ...
+      endchoice
+
+    The following attributes are available on Choice instances. They should be
+    treated as read-only, and some are implemented through @property magic (but
+    are still efficient to access due to internal caching).
+
+    Note: Prompts, help texts, and locations are stored in the Choice's
+    MenuNode(s) rather than in the Choice itself. Check the MenuNode class and
+    the Choice.nodes attribute. This organization matches the C tools.
+
+    name:
+      The name of the choice, e.g. "FOO" for 'choice FOO', or None if the
+      Choice has no name. I can't remember ever seeing named choices in
+      practice, but the C tools support them too.
+
+    type:
+      The type of the choice. One of BOOL, TRISTATE, UNKNOWN. UNKNOWN is for
+      choices defined without a type where none of the contained symbols have a
+      type either (otherwise the choice inherits the type of the first symbol
+      defined with a type).
+
+      When running without modules (CONFIG_MODULES=n), TRISTATE choices
+      magically change type to BOOL. This matches the C tools, and makes sense
+      for menuconfig-like functionality.
+
+    orig_type:
+      The type as given in the Kconfig file, without any magic applied. Used
+      when printing the choice.
+
+    tri_value:
+      The tristate value (mode) of the choice. A choice can be in one of three
+      modes:
+
+        0 (n) - The choice is disabled and no symbols can be selected. For
+                visible choices, this mode is only possible for choices with
+                the 'optional' flag set (see kconfig-language.txt).
+
+        1 (m) - Any number of choice symbols can be set to m, the rest will
+                be n.
+
+        2 (y) - One symbol will be y, the rest n.
+
+      Only tristate choices can be in m mode. The visibility of the choice is
+      an upper bound on the mode, and the mode in turn is an upper bound on the
+      visibility of the choice symbols.
+
+      To change the mode, use Choice.set_value().
+
+      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 visible non-optional choices (the reverse
+        dependency is 'm && <visibility>').
+
+        Symbols within choices get the choice propagated as a dependency to
+        their properties. This turns the mode of the choice into an upper bound
+        on e.g. the visibility of choice symbols, and explains the gotcha
+        related to printing choice symbols mentioned in the module docstring.
+
+        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 and compatibility.
+
+    assignable:
+      See the symbol class documentation. Gives the assignable values (modes).
+
+    visibility:
+      See the Symbol class documentation. Acts on the value (mode).
+
+    selection:
+      The Symbol instance of the currently selected symbol. None if the Choice
+      is not in y mode or has no selected symbol (due to unsatisfied
+      dependencies on choice symbols).
+
+      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.
+
+    user_value:
+      The value (mode) selected by the user through Choice.set_value(). Either
+      0, 1, or 2, or None if the user hasn't selected a mode. See
+      Symbol.user_value.
+
+      WARNING: Do not assign directly to this. It will break things. Use
+      Choice.set_value() instead.
+
+    user_selection:
+      The symbol selected by the user (by setting it to y). Ignored if the
+      choice is not in y mode, but still remembered so that the choice "snaps
+      back" to the user selection if the mode is changed back to y. This might
+      differ from 'selection' due to unsatisfied dependencies.
+
+      WARNING: Do not assign directly to this. It will break things. Call
+      sym.set_value(2) on the choice symbol to be selected instead.
+
+    syms:
+      List of symbols contained in the choice.
+
+      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 to support in older versions of Kconfiglib that didn't implement
+      the menu structure.
+
+    nodes:
+      A list of MenuNodes for this choice. In practice, the list will probably
+      always contain a single MenuNode, but it is possible to give a choice a
+      name and define it in multiple locations (i've never even seen a named
+      choice though).
+
+    defaults:
+      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 and can be in
+      n mode.
+
+    kconfig:
+      The Kconfig instance this choice is from.
+    """
+    __slots__ = (
+        "_cached_assignable",
+        "_cached_selection",
+        "_cached_vis",
+        "_dependents",
+        "_was_set",
+        "defaults",
+        "is_constant",
+        "is_optional",
+        "kconfig",
+        "name",
+        "nodes",
+        "orig_type",
+        "syms",
+        "user_selection",
+        "user_value",
+    )
+
+    #
+    # Public interface
+    #
+
+    @property
+    def type(self):
+        """
+        Returns the type of the choice. See Symbol.type.
+        """
+        if self.orig_type == TRISTATE and not self.kconfig.modules.tri_value:
+            return BOOL
+
+        return self.orig_type
+
+    @property
+    def str_value(self):
+        """
+        See the class documentation.
+        """
+        return TRI_TO_STR[self.tri_value]
+
+    @property
+    def tri_value(self):
+        """
+        See the class documentation.
+        """
+        # This emulates a reverse dependency of 'm && visibility' for
+        # non-optional choices, which is how the C implementation does it
+
+        val = 0 if self.is_optional else 1
+
+        if self.user_value is not None:
+            val = max(val, self.user_value)
+
+        # Warning: See Symbol._rec_invalidate(), and note that this is a hidden
+        # function call (property magic)
+        val = min(val, self.visibility)
+
+        # Promote m to y for boolean choices
+        return 2 if val == 1 and self.type == BOOL else val
+
+    @property
+    def assignable(self):
+        """
+        See the class documentation.
+        """
+        if self._cached_assignable is not None:
+            return self._cached_assignable
+
+        self._cached_assignable = self._get_assignable()
+        return self._cached_assignable
+
+    @property
+    def visibility(self):
+        """
+        See the class documentation.
+        """
+        if self._cached_vis is not None:
+            return self._cached_vis
+
+        self._cached_vis = _get_visibility(self)
+        return self._cached_vis
+
+    @property
+    def selection(self):
+        """
+        See the class documentation.
+        """
+        if self._cached_selection is not _NO_CACHED_SELECTION:
+            return self._cached_selection
+
+        self._cached_selection = self._get_selection()
+        return self._cached_selection
+
+    def set_value(self, value):
+        """
+        Sets the user value (mode) of the choice. Like for Symbol.set_value(),
+        the visibility might truncate the value. Choices without the 'optional'
+        attribute (is_optional) can never be in n mode, but 0 is still accepted
+        since it's not a malformed value (though it will have no effect).
+
+        Returns True if the value is valid for the type of the choice, and
+        False otherwise. This only looks at the form of the value. Check the
+        Choice.assignable attribute to see what values are currently in range
+        and would actually be reflected in the mode of the choice.
+        """
+        if value == self.user_value:
+            # We know the value must be valid if it was successfully set
+            # previously
+            self._was_set = True
+            return True
+
+        if not ((self.orig_type == BOOL     and value in (0, 2)    ) or
+                (self.orig_type == TRISTATE and value in (0, 1, 2))):
+            self.kconfig._warn("the value '{}' is invalid for the choice, "
+                               "which has type {}. Assignment ignored"
+                               .format(value, TYPE_TO_STR[self.orig_type]))
+            return False
+
+        self.user_value = value
+        self._was_set = True
+        self._rec_invalidate()
+
+        return True
+
+    def unset_value(self):
+        """
+        Resets the user value (mode) and user selection of the Choice, as if
+        the user had never touched the mode or any of the choice symbols.
+        """
+        if self.user_value is not None or self.user_selection:
+            self.user_value = self.user_selection = None
+            self._rec_invalidate()
+
+    def __repr__(self):
+        """
+        Returns a string with information about the choice when it is evaluated
+        on e.g. the interactive Python prompt.
+        """
+        fields = []
+
+        fields.append("choice" if self.name is None else \
+                      "choice " + self.name)
+        fields.append(TYPE_TO_STR[self.type])
+
+        for node in self.nodes:
+            if node.prompt:
+                fields.append('"{}"'.format(node.prompt[0]))
+
+        fields.append("mode " + self.str_value)
+
+        if self.user_value is not None:
+            fields.append('user mode {}'.format(TRI_TO_STR[self.user_value]))
+
+        if self.selection:
+            fields.append("{} selected".format(self.selection.name))
+
+        if self.user_selection:
+            user_sel_str = "{} selected by user" \
+                           .format(self.user_selection.name)
+
+            if self.selection is not self.user_selection:
+                user_sel_str += " (overridden)"
+
+            fields.append(user_sel_str)
+
+        fields.append("visibility " + TRI_TO_STR[self.visibility])
+
+        if self.is_optional:
+            fields.append("optional")
+
+        for node in self.nodes:
+            fields.append("{}:{}".format(node.filename, node.linenr))
+
+        return "<{}>".format(", ".join(fields))
+
+    def __str__(self):
+        """
+        Returns a string representation of the choice when it is printed,
+        matching the Kconfig format (though without the contained choice
+        symbols). Prompts and help texts are included, though they really
+        belong to the choice's menu nodes rather than the choice itself.
+
+        See Symbol.__str__() as well.
+        """
+        return _sym_choice_str(self)
+
+    #
+    # Private methods
+    #
+
+    def __init__(self):
+        """
+        Choice constructor -- not intended to be called directly by Kconfiglib
+        clients.
+        """
+        # These attributes are always set on the instance from outside and
+        # don't need defaults:
+        #   kconfig
+
+        self.orig_type = UNKNOWN
+        self.syms = []
+        self.defaults = []
+
+        self.nodes = []
+
+        self.name = \
+        self.user_value = self.user_selection = \
+        self._cached_vis = self._cached_assignable = None
+
+        self._cached_selection = _NO_CACHED_SELECTION
+
+        # is_constant is checked by _make_depend_on(). Just set it to avoid
+        # having to special-case choices.
+        self.is_constant = self.is_optional = False
+
+        # See Kconfig._build_dep()
+        self._dependents = set()
+
+    def _get_assignable(self):
+        """
+        Worker function for the 'assignable' attribute.
+        """
+        # Warning: See Symbol._rec_invalidate(), and note that this is a hidden
+        # function call (property magic)
+        vis = self.visibility
+
+        if not vis:
+            return ()
+
+        if vis == 2:
+            if not self.is_optional:
+                return (2,) if self.type == BOOL else (1, 2)
+            return (0, 2) if self.type == BOOL else (0, 1, 2)
+
+        # vis == 1
+
+        return (0, 1) if self.is_optional else (1,)
+
+    def _get_selection(self):
+        """
+        Worker function for the 'selection' attribute.
+        """
+        # Warning: See Symbol._rec_invalidate(), and note that this is a hidden
+        # function call (property magic)
+        if self.tri_value != 2:
+            return None
+
+        # Use the user selection if it's visible
+        if self.user_selection and self.user_selection.visibility == 2:
+            return self.user_selection
+
+        # Otherwise, check if we have a default
+        for sym, cond in self.defaults:
+            # The default symbol must be visible too
+            if expr_value(cond) and sym.visibility:
+                return sym
+
+        # Otherwise, pick the first visible symbol, if any
+        for sym in self.syms:
+            if sym.visibility:
+                return sym
+
+        # Couldn't find a selection
+        return None
+
+    def _invalidate(self):
+        self._cached_vis = self._cached_assignable = None
+        self._cached_selection = _NO_CACHED_SELECTION
+
+    def _rec_invalidate(self):
+        """
+        See Symbol._rec_invalidate()
+        """
+        self._invalidate()
+
+        for item in self._dependents:
+            if item._cached_vis is not None:
+                item._rec_invalidate()
+
+class MenuNode(object):
+    """
+    Represents a menu node in the configuration. This corresponds to an entry
+    in e.g. the 'make menuconfig' interface, though non-visible choices, menus,
+    and comments also get menu nodes. If a symbol or choice is defined in
+    multiple locations, it gets one menu node for each location.
+
+    The top-level menu node, corresponding to the implicit top-level menu, is
+    available in Kconfig.top_node.
+
+    The menu nodes for a Symbol or Choice can be found in the
+    Symbol/Choice.nodes attribute. Menus and comments are represented as plain
+    menu nodes, with their text stored in the prompt attribute (prompt[0]).
+    This mirrors the C implementation.
+
+    The following attributes are available on MenuNode instances. They should
+    be viewed as read-only.
+
+    item:
+      Either a Symbol, a Choice, or one of the constants MENU and COMMENT.
+      Menus and comments are represented as plain menu nodes. Ifs are collapsed
+      (matching the C implementation) and do not appear in the final menu tree.
+
+    next:
+      The following menu node. None if there is no following node.
+
+    list:
+      The first child menu node. None if there are no children.
+
+      Choices and menus naturally have children, but Symbols can also have
+      children because of menus created automatically from dependencies (see
+      kconfig-language.txt).
+
+    parent:
+      The parent menu node. None if there is no parent.
+
+    prompt:
+      A (string, cond) tuple with the prompt for the menu node and its
+      conditional expression (which is self.kconfig.y if there is no
+      condition). None if there is no prompt.
+
+      For symbols and choices, the prompt is stored in the MenuNode rather than
+      the Symbol or Choice instance. For menus and comments, the prompt holds
+      the text.
+
+    help:
+      The help text for the menu node for Symbols and Choices. None if there is
+      no help text. Always stored in the node rather than the Symbol or Choice.
+      It is possible to have a separate help text at each location if a symbol
+      is defined in multiple locations.
+
+    dep:
+      The 'depends on' dependencies for the menu node, or self.kconfig.y if
+      there are no dependencies. Parent dependencies are propagated to this
+      attribute, and this attribute is then in turn propagated to the
+      properties of symbols and choices.
+
+      If a symbol is defined in multiple locations, only the properties defined
+      at a particular location get the corresponding MenuNode.dep dependencies
+      propagated to them.
+
+    visibility:
+      The 'visible if' dependencies for the menu node (which must represent a
+      menu), or self.kconfig.y if there are no 'visible if' dependencies.
+      'visible if' dependencies are recursively propagated to the prompts of
+      symbols and choices within the menu.
+
+    is_menuconfig:
+      True if the symbol for the menu node (it must be a symbol) was defined
+      with 'menuconfig' rather than 'config' (at this location). This is a hint
+      on how to display the menu entry (display the children in a separate menu
+      rather than indenting them). It's ignored internally by Kconfiglib,
+      except when printing symbols.
+
+    filename/linenr:
+      The location where the menu node appears.
+
+    kconfig:
+      The Kconfig instance the menu node is from.
+    """
+    __slots__ = (
+        "dep",
+        "filename",
+        "help",
+        "is_menuconfig",
+        "item",
+        "kconfig",
+        "linenr",
+        "list",
+        "next",
+        "parent",
+        "prompt",
+        "visibility",
+    )
+
+    def __repr__(self):
+        """
+        Returns a string with information about the menu node when it is
+        evaluated on e.g. the interactive Python prompt.
+        """
+        fields = []
+
+        if isinstance(self.item, Symbol):
+            fields.append("menu node for symbol " + self.item.name)
+
+        elif isinstance(self.item, Choice):
+            s = "menu node for choice"
+            if self.item.name is not None:
+                s += " " + self.item.name
+            fields.append(s)
+
+        elif self.item == MENU:
+            fields.append("menu node for menu")
+
+        elif self.item == COMMENT:
+            fields.append("menu node for comment")
+
+        elif self.item is None:
+            fields.append("menu node for if (should not appear in the final "
+                          " tree)")
+
+        else:
+            raise InternalError("unable to determine type in "
+                                "MenuNode.__repr__()")
+
+        if self.prompt:
+            fields.append('prompt "{}" (visibility {})'
+                          .format(self.prompt[0],
+                                  TRI_TO_STR[expr_value(self.prompt[1])]))
+
+        if isinstance(self.item, Symbol) and self.is_menuconfig:
+            fields.append("is menuconfig")
+
+        fields.append("deps " + TRI_TO_STR[expr_value(self.dep)])
+
+        if self.item == MENU:
+            fields.append("'visible if' deps " + \
+                          TRI_TO_STR[expr_value(self.visibility)])
+
+        if isinstance(self.item, (Symbol, Choice)) and self.help is not None:
+            fields.append("has help")
+
+        if self.list:
+            fields.append("has child")
+
+        if self.next:
+            fields.append("has next")
+
+        fields.append("{}:{}".format(self.filename, self.linenr))
+
+        return "<{}>".format(", ".join(fields))
+
+    def __str__(self):
+        """
+        Returns a string representation of the MenuNode, matching the Kconfig
+        format.
+
+        For Symbol and Choice menu nodes, this function simply calls through to
+        MenuNode.item.__str__(). For MENU and COMMENT nodes, a Kconfig-like
+        representation of the menu or comment is returned.
+        """
+        if isinstance(self.item, (Symbol, Choice)):
+            return self.item.__str__()
+
+        if self.item in (MENU, COMMENT):
+            s = ("menu" if self.item == MENU else "comment") + \
+                ' "{}"\n'.format(escape(self.prompt[0]))
+
+            if self.dep is not self.kconfig.y:
+                s += "\tdepends on {}\n".format(expr_str(self.dep))
+
+            if self.item == MENU and self.visibility is not self.kconfig.y:
+                s += "\tvisible if {}\n".format(expr_str(self.visibility))
+
+            return s
+
+        # 'if' node. Should never appear in the final tree.
+        return "if " + expr_str(self.dep)
+
+class KconfigSyntaxError(Exception):
+    """
+    Exception raised for syntax errors.
+    """
+    pass
+
+class InternalError(Exception):
+    """
+    Exception raised for internal errors.
+    """
+    pass
+
+#
+# Public functions
+#
+
+def expr_value(expr):
+    """
+    Evaluates the expression 'expr' to a tristate value. Returns 0 (n), 1 (m),
+    or 2 (y).
+
+    'expr' must be an already-parsed expression from a Symbol, Choice, or
+    MenuNode property. To evaluate an expression represented as a string, use
+    Kconfig.eval_string().
+
+    Passing subexpressions of expressions to this function works as expected.
+    """
+    if not isinstance(expr, tuple):
+        return expr.tri_value
+
+    if expr[0] == AND:
+        v1 = expr_value(expr[1])
+        # Short-circuit the n case as an optimization (~5% faster
+        # allnoconfig.py and allyesconfig.py, as of writing)
+        return 0 if not v1 else min(v1, expr_value(expr[2]))
+
+    if expr[0] == OR:
+        v1 = expr_value(expr[1])
+        # Short-circuit the y case as an optimization
+        return 2 if v1 == 2 else max(v1, expr_value(expr[2]))
+
+    if expr[0] == NOT:
+        return 2 - expr_value(expr[1])
+
+    if expr[0] in _RELATIONS:
+        # Implements <, <=, >, >= comparisons as well. These were added to
+        # kconfig in 31847b67 (kconfig: allow use of relations other than
+        # (in)equality).
+
+        # This mirrors the C tools pretty closely. Perhaps there's a more
+        # pythonic way to structure this.
+
+        oper, op1, op2 = expr
+
+        # If both operands are strings...
+        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.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
+                comp = _strcmp(op1.str_value, op2.str_value)
+
+        if   oper == EQUAL:         res = comp == 0
+        elif oper == UNEQUAL:       res = comp != 0
+        elif oper == LESS:          res = comp < 0
+        elif oper == LESS_EQUAL:    res = comp <= 0
+        elif oper == GREATER:       res = comp > 0
+        elif oper == GREATER_EQUAL: res = comp >= 0
+
+        return 2*res
+
+    _internal_error("Internal error while evaluating expression: "
+                    "unknown operation {}.".format(expr[0]))
+
+def expr_str(expr):
+    """
+    Returns the string representation of the expression 'expr', as in a Kconfig
+    file.
+
+    Passing subexpressions of expressions to this function works as expected.
+    """
+    if not isinstance(expr, tuple):
+        if isinstance(expr, Choice):
+            if expr.name is not None:
+                return "<choice {}>".format(expr.name)
+            return "<choice>"
+
+        # Symbol
+
+        if expr.is_constant:
+            return '"{}"'.format(escape(expr.name))
+
+        return expr.name
+
+    if expr[0] == NOT:
+        if isinstance(expr[1], Symbol):
+            return "!" + expr_str(expr[1])
+        return "!({})".format(expr_str(expr[1]))
+
+    if expr[0] == AND:
+        return "{} && {}".format(_format_and_op(expr[1]),
+                                 _format_and_op(expr[2]))
+
+    if expr[0] == OR:
+        return "{} || {}".format(expr_str(expr[1]), expr_str(expr[2]))
+
+    # Relation
+    return "{} {} {}".format(expr_str(expr[1]),
+                             _REL_TO_STR[expr[0]],
+                             expr_str(expr[2]))
+
+# escape()/unescape() helpers
+_escape_re_sub = re.compile(r'(["\\])').sub
+_unescape_re_sub = re.compile(r"\\(.)").sub
+
+def escape(s):
+    r"""
+    Escapes the string 's' in the same fashion as is done for display in
+    Kconfig format and when writing strings to a .config file. " and \ are
+    replaced by \" and \\, respectively.
+    """
+    return _escape_re_sub(r"\\\1", s)
+
+def unescape(s):
+    r"""
+    Unescapes the string 's'. \ followed by any character is replaced with just
+    that character. Used internally when reading .config files.
+    """
+    return _unescape_re_sub(r"\1", s)
+
+#
+# Internal functions
+#
+
+def _get_visibility(sc):
+    """
+    Symbols and Choices have a "visibility" that acts as an upper bound on the
+    values a user can set for them, corresponding to the visibility in e.g.
+    'make menuconfig'. This function calculates the visibility for the Symbol
+    or Choice 'sc' -- the logic is nearly identical.
+    """
+    vis = 0
+
+    for node in sc.nodes:
+        if node.prompt:
+            vis = max(vis, expr_value(node.prompt[1]))
+
+    if isinstance(sc, Symbol) and sc.choice:
+        if sc.choice.orig_type == TRISTATE and sc.orig_type != TRISTATE and \
+           sc.choice.tri_value != 2:
+            # Non-tristate choice symbols are only visible in y mode
+            return 0
+
+        if sc.orig_type == TRISTATE and vis == 1 and sc.choice.tri_value == 2:
+            # Choice symbols with m visibility are not visible in y mode
+            return 0
+
+    # Promote m to y if we're dealing with a non-tristate (possibly due to
+    # modules being disabled)
+    if vis == 1 and sc.type != TRISTATE:
+        return 2
+
+    return vis
+
+def _make_depend_on(sym, expr):
+    """
+    Adds 'sym' as a dependency to all symbols in 'expr'. Constant symbols in
+    'expr' are skipped as they can never change value anyway.
+    """
+    if not isinstance(expr, tuple):
+        if not expr.is_constant:
+            expr._dependents.add(sym)
+
+    elif expr[0] in (AND, OR):
+        _make_depend_on(sym, expr[1])
+        _make_depend_on(sym, expr[2])
+
+    elif expr[0] == NOT:
+        _make_depend_on(sym, expr[1])
+
+    elif expr[0] in _RELATIONS:
+        if not expr[1].is_constant:
+            expr[1]._dependents.add(sym)
+        if not expr[2].is_constant:
+            expr[2]._dependents.add(sym)
+
+    else:
+        _internal_error("Internal error while fetching symbols from an "
+                        "expression with token stream {}.".format(expr))
+
+def _format_and_op(expr):
+    """
+    expr_str() helper. Returns the string representation of 'expr', which is
+    assumed to be an operand to AND, with parentheses added if needed.
+    """
+    if isinstance(expr, tuple) and expr[0] == OR:
+        return "({})".format(expr_str(expr))
+    return expr_str(expr)
+
+def _indentation(line):
+    """
+    Returns the length of the line's leading whitespace, treating tab stops as
+    being spaced 8 characters apart.
+    """
+    line = line.expandtabs()
+    return len(line) - len(line.lstrip())
+
+def _deindent(line, indent):
+    """
+    Deindents 'line' by 'indent' spaces.
+    """
+    line = line.expandtabs()
+    if len(line) <= indent:
+        return line
+    return line[indent:]
+
+def _is_base_n(s, n):
+    try:
+        int(s, n)
+        return True
+    except ValueError:
+        return False
+
+def _strcmp(s1, s2):
+    """
+    strcmp()-alike that returns -1, 0, or 1.
+    """
+    return (s1 > s2) - (s1 < s2)
+
+def _stderr_msg(msg, filename, linenr):
+    if filename is not None:
+        msg = "{}:{}: {}".format(filename, linenr, msg)
+
+    sys.stderr.write(msg + "\n")
+
+def _internal_error(msg):
+    raise InternalError(
+        msg +
+        "\nSorry! You may want to send an email to ulfalizer a.t Google's "
+        "email service to tell me about this. Include the message above and "
+        "the stack trace and describe what you were doing.")
+
+# Printing functions
+
+def _sym_choice_str(sc):
+    """
+    Symbol/choice __str__() implementation. These have many properties in
+    common, so it makes sense to handle them together.
+    """
+    lines = []
+
+    def indent_add(s):
+        lines.append("\t" + s)
+
+    # We print the prompt(s) and help text(s) too as a convenience, even though
+    # they're actually part of the MenuNode. If a symbol or choice is defined
+    # in multiple locations (has more than one MenuNode), we output one
+    # statement for each location, and print all the properties that belong to
+    # the symbol/choice itself only at the first location. This gives output
+    # that would function if fed to a Kconfig parser, even for such
+    # symbols/choices (choices defined in multiple locations gets a bit iffy
+    # since they also have child nodes, though I've never seen such a choice).
+
+    if not sc.nodes:
+        return ""
+
+    for node in sc.nodes:
+        if isinstance(sc, Symbol):
+            if node.is_menuconfig:
+                lines.append("menuconfig " + sc.name)
+            else:
+                lines.append("config " + sc.name)
+        else:
+            if sc.name is None:
+                lines.append("choice")
+            else:
+                lines.append("choice " + sc.name)
+
+        if node is sc.nodes[0] and sc.orig_type != UNKNOWN:
+            indent_add(TYPE_TO_STR[sc.orig_type])
+
+        if node.prompt:
+            prompt, cond = node.prompt
+            prompt_str = 'prompt "{}"'.format(escape(prompt))
+            if cond is not sc.kconfig.y:
+                prompt_str += " if " + expr_str(cond)
+            indent_add(prompt_str)
+
+        if node is sc.nodes[0]:
+            if isinstance(sc, Symbol):
+                if sc.is_allnoconfig_y:
+                    indent_add("option allnoconfig_y")
+
+                if sc is sc.kconfig.defconfig_list:
+                    indent_add("option defconfig_list")
+
+                if sc.env_var is not None:
+                    indent_add('option env="{}"'.format(sc.env_var))
+
+                if sc is sc.kconfig.modules:
+                    indent_add("option modules")
+
+            if isinstance(sc, Symbol):
+                for low, high, cond in sc.ranges:
+                    range_string = "range {} {}" \
+                                   .format(expr_str(low), expr_str(high))
+                    if cond is not sc.kconfig.y:
+                        range_string += " if " + expr_str(cond)
+                    indent_add(range_string)
+
+            for default, cond in sc.defaults:
+                default_string = "default " + expr_str(default)
+                if cond is not sc.kconfig.y:
+                    default_string += " if " + expr_str(cond)
+                indent_add(default_string)
+
+            if isinstance(sc, Choice) and sc.is_optional:
+                indent_add("optional")
+
+            if isinstance(sc, Symbol):
+                for select, cond in sc.selects:
+                    select_string = "select " + select.name
+                    if cond is not sc.kconfig.y:
+                        select_string += " if " + expr_str(cond)
+                    indent_add(select_string)
+
+                for imply, cond in sc.implies:
+                    imply_string = "imply " + imply.name
+                    if cond is not sc.kconfig.y:
+                        imply_string += " if " + expr_str(cond)
+                    indent_add(imply_string)
+
+        if node.help is not None:
+            indent_add("help")
+            for line in node.help.splitlines():
+                indent_add("  " + line)
+
+        # Add a blank line if there are more nodes to print
+        if node is not sc.nodes[-1]:
+            lines.append("")
+
+    return "\n".join(lines) + "\n"
+
+# Menu manipulation
+
+def _expr_depends_on(expr, sym):
+    """
+    Reimplementation of expr_depends_symbol() from mconf.c. Used to
+    determine if a submenu should be implicitly created. This also influences
+    which items inside choice statements are considered choice items.
+    """
+    if not isinstance(expr, tuple):
+        return expr is sym
+
+    if expr[0] in (EQUAL, UNEQUAL):
+        # Check for one of the following:
+        # sym = m/y, m/y = sym, sym != n, n != sym
+
+        left, right = expr[1:]
+
+        if right is sym:
+            left, right = right, left
+
+        if left is not sym:
+            return False
+
+        return (expr[0] == EQUAL and right is sym.kconfig.m or \
+                                     right is sym.kconfig.y) or \
+               (expr[0] == UNEQUAL and right is sym.kconfig.n)
+
+    if expr[0] == AND:
+        return _expr_depends_on(expr[1], sym) or \
+               _expr_depends_on(expr[2], sym)
+
+    return False
+
+def _has_auto_menu_dep(node1, node2):
+    """
+    Returns True if node2 has an "automatic menu dependency" on node1. If node2
+    has a prompt, we check its condition. Otherwise, we look directly at
+    node2.dep.
+    """
+    if node2.prompt:
+        return _expr_depends_on(node2.prompt[1], node1.item)
+
+    # If we have no prompt, use the menu node dependencies instead
+    return _expr_depends_on(node2.dep, node1.item)
+
+def _check_auto_menu(node):
+    """
+    Looks for menu nodes after 'node' that depend on it. Creates an implicit
+    menu rooted at 'node' with the nodes as the children if such nodes are
+    found. The recursive call to _finalize_tree() makes this work recursively.
+    """
+    cur = node
+    while cur.next and _has_auto_menu_dep(node, cur.next):
+        _finalize_tree(cur.next)
+        cur = cur.next
+        cur.parent = node
+
+    if cur is not node:
+        node.list = node.next
+        node.next = cur.next
+        cur.next = None
+
+def _flatten(node):
+    """
+    "Flattens" menu nodes without prompts (e.g. 'if' nodes and non-visible
+    symbols with children from automatic menu creation) so that their children
+    appear after them instead. This gives a clean menu structure with no
+    unexpected "jumps" in the indentation.
+    """
+    while node:
+        if node.list and (not node.prompt or node.prompt[0] == ""):
+
+            last_node = node.list
+            while 1:
+                last_node.parent = node.parent
+                if not last_node.next:
+                    break
+                last_node = last_node.next
+
+            last_node.next = node.next
+            node.next = node.list
+            node.list = None
+
+        node = node.next
+
+def _remove_ifs(node):
+    """
+    Removes 'if' nodes (which can be recognized by MenuNode.item being None),
+    which are assumed to already have been flattened. The C implementation
+    doesn't bother to do this, but we expose the menu tree directly, and it
+    makes it nicer to work with.
+    """
+    first = node.list
+    while first and first.item is None:
+        first = first.next
+
+    cur = first
+    while cur:
+        if cur.next and cur.next.item is None:
+            cur.next = cur.next.next
+        cur = cur.next
+
+    node.list = first
+
+def _finalize_choice(node):
+    """
+    Finalizes a choice, marking each symbol whose menu node has the choice as
+    the parent as a choice symbol, and automatically determining types if not
+    specified.
+    """
+    choice = node.item
+
+    cur = node.list
+    while cur:
+        if isinstance(cur.item, Symbol):
+            cur.item.choice = choice
+            choice.syms.append(cur.item)
+        cur = cur.next
+
+    # If no type is specified for the choice, its type is that of
+    # the first choice item with a specified type
+    if choice.orig_type == UNKNOWN:
+        for item in choice.syms:
+            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 sym in choice.syms:
+        if sym.orig_type == UNKNOWN:
+            sym.orig_type = choice.orig_type
+
+def _finalize_tree(node):
+    """
+    Creates implicit menus from dependencies (see kconfig-language.txt),
+    removes 'if' nodes, and finalizes choices. This pretty closely mirrors
+    menu_finalize() from the C implementation, though we propagate dependencies
+    during parsing instead.
+    """
+    # The ordering here gets a bit tricky. It's important to do things in this
+    # order to have everything work out correctly.
+
+    if node.list:
+        # The menu node has children. Finalize them.
+        cur = node.list
+        while cur:
+            _finalize_tree(cur)
+            # Note: _finalize_tree() might have changed cur.next. This is
+            # expected, so that we jump over e.g. implicitly created submenus.
+            cur = cur.next
+
+    elif node.item is not None:
+        # The menu node has no children (yet). See if we can create an implicit
+        # menu rooted at it (due to menu nodes after it depending on it).
+        _check_auto_menu(node)
+
+    if node.list:
+        # We have a node with finalized children. Do final steps to finalize
+        # this node.
+        _flatten(node.list)
+        _remove_ifs(node)
+
+    # Empty choices (node.list None) are possible, so this needs to go outside
+    if isinstance(node.item, Choice):
+        _finalize_choice(node)
+
+def _wordexp_expand(value):
+    """
+    Return a list of expanded tokens, using roughly the same algorithm
+    as wordexp(3)
+    """
+    ifs = os.environ.get("IFS", " \t\n")
+    value = os.path.expandvars(value).strip(ifs)
+    if len(ifs) > 0:
+        for i in ifs[1:]:  # collapse all IFS delimiters
+            value = value.replace(i, ifs[0])
+        return value.split(ifs[0])
+    else:
+        return [value]
+
+#
+# Public global constants
+#
+
+# Integers representing symbol types
+(
+    BOOL,
+    HEX,
+    INT,
+    STRING,
+    TRISTATE,
+    UNKNOWN
+) = range(6)
+
+# Integers representing expression types
+(
+    AND,
+    OR,
+    NOT,
+    EQUAL,
+    UNEQUAL,
+    LESS,
+    LESS_EQUAL,
+    GREATER,
+    GREATER_EQUAL,
+) = range(9)
+
+# Integers representing menu and comment menu nodes
+(
+    MENU,
+    COMMENT,
+) = range(2)
+
+# Converts a symbol/choice type to a string
+TYPE_TO_STR = {
+    UNKNOWN:  "unknown",
+    BOOL:     "bool",
+    TRISTATE: "tristate",
+    STRING:   "string",
+    HEX:      "hex",
+    INT:      "int",
+}
+
+TRI_TO_STR = {
+    0: "n",
+    1: "m",
+    2: "y",
+}
+
+STR_TO_TRI = {
+    "n": 0,
+    "m": 1,
+    "y": 2,
+}
+
+#
+# Internal global constants
+#
+
+# Tokens
+(
+    _T_ALLNOCONFIG_Y,
+    _T_AND,
+    _T_BOOL,
+    _T_CHOICE,
+    _T_CLOSE_PAREN,
+    _T_COMMENT,
+    _T_CONFIG,
+    _T_DEFAULT,
+    _T_DEFCONFIG_LIST,
+    _T_DEF_BOOL,
+    _T_DEF_TRISTATE,
+    _T_DEPENDS,
+    _T_ENDCHOICE,
+    _T_ENDIF,
+    _T_ENDMENU,
+    _T_ENV,
+    _T_EQUAL,
+    _T_GREATER,
+    _T_GREATER_EQUAL,
+    _T_HELP,
+    _T_HEX,
+    _T_IF,
+    _T_IMPLY,
+    _T_INT,
+    _T_LESS,
+    _T_LESS_EQUAL,
+    _T_MAINMENU,
+    _T_MENU,
+    _T_MENUCONFIG,
+    _T_MODULES,
+    _T_NOT,
+    _T_ON,
+    _T_OPEN_PAREN,
+    _T_OPTION,
+    _T_OPTIONAL,
+    _T_OR,
+    _T_PROMPT,
+    _T_RANGE,
+    _T_SELECT,
+    _T_SOURCE,
+    _T_STRING,
+    _T_TRISTATE,
+    _T_UNEQUAL,
+    _T_VISIBLE,
+) = range(44)
+
+# Keyword to token map, with the get() method assigned directly as a small
+# optimization
+_get_keyword = {
+    "allnoconfig_y":  _T_ALLNOCONFIG_Y,
+    "bool":           _T_BOOL,
+    "boolean":        _T_BOOL,
+    "choice":         _T_CHOICE,
+    "comment":        _T_COMMENT,
+    "config":         _T_CONFIG,
+    "def_bool":       _T_DEF_BOOL,
+    "def_tristate":   _T_DEF_TRISTATE,
+    "default":        _T_DEFAULT,
+    "defconfig_list": _T_DEFCONFIG_LIST,
+    "depends":        _T_DEPENDS,
+    "endchoice":      _T_ENDCHOICE,
+    "endif":          _T_ENDIF,
+    "endmenu":        _T_ENDMENU,
+    "env":            _T_ENV,
+    "help":           _T_HELP,
+    "hex":            _T_HEX,
+    "if":             _T_IF,
+    "imply":          _T_IMPLY,
+    "int":            _T_INT,
+    "mainmenu":       _T_MAINMENU,
+    "menu":           _T_MENU,
+    "menuconfig":     _T_MENUCONFIG,
+    "modules":        _T_MODULES,
+    "on":             _T_ON,
+    "option":         _T_OPTION,
+    "optional":       _T_OPTIONAL,
+    "prompt":         _T_PROMPT,
+    "range":          _T_RANGE,
+    "select":         _T_SELECT,
+    "source":         _T_SOURCE,
+    "string":         _T_STRING,
+    "tristate":       _T_TRISTATE,
+    "visible":        _T_VISIBLE,
+}.get
+
+# Tokens after which identifier-like lexemes are treated as strings. _T_CHOICE
+# is included to avoid symbols being registered for named choices.
+_STRING_LEX = frozenset((
+    _T_BOOL,
+    _T_CHOICE,
+    _T_COMMENT,
+    _T_HEX,
+    _T_INT,
+    _T_MAINMENU,
+    _T_MENU,
+    _T_PROMPT,
+    _T_SOURCE,
+    _T_STRING,
+    _T_TRISTATE,
+))
+
+# Tokens for types, excluding def_bool, def_tristate, etc., for quick
+# checks during parsing
+_TYPE_TOKENS = frozenset((
+    _T_BOOL,
+    _T_TRISTATE,
+    _T_INT,
+    _T_HEX,
+    _T_STRING,
+))
+
+# Note: This hack is no longer needed as of upstream commit c226456
+# (kconfig: warn of unhandled characters in Kconfig commands). It
+# is kept around for backwards compatibility.
+#
+# The initial word on a line is parsed specially. Let
+# command_chars = [A-Za-z0-9_]. Then
+#  - leading non-command_chars characters are ignored, and
+#  - the first token consists the following one or more
+#    command_chars characters.
+# This is why things like "----help--" are accepted.
+#
+# In addition to the initial token, the regex also matches trailing whitespace
+# so that we can jump straight to the next token (or to the end of the line if
+# there's just a single token).
+#
+# As an optimization, this regex fails to match for lines containing just a
+# comment.
+_initial_token_re_match = re.compile(r"[^\w#]*(\w+)\s*").match
+
+# Matches an identifier/keyword, also eating trailing whitespace
+_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
+
+# Matches a valid right-hand side for an assignment to a string symbol in a
+# .config file, including escaped characters. Extracts the contents.
+_conf_string_re_match = re.compile(r'"((?:[^\\"]|\\.)*)"').match
+
+# Token to type mapping
+_TOKEN_TO_TYPE = {
+    _T_BOOL:         BOOL,
+    _T_DEF_BOOL:     BOOL,
+    _T_DEF_TRISTATE: TRISTATE,
+    _T_HEX:          HEX,
+    _T_INT:          INT,
+    _T_STRING:       STRING,
+    _T_TRISTATE:     TRISTATE,
+}
+
+# Constant representing that there's no cached choice selection. This is
+# distinct from a cached None (no selection). We create a unique object (any
+# will do) for it so we can test with 'is'.
+_NO_CACHED_SELECTION = object()
+
+# Used in comparisons. 0 means the base is inferred from the format of the
+# string. The entries for BOOL and TRISTATE are an implementation convenience:
+# They should never convert to valid numbers.
+_TYPE_TO_BASE = {
+    BOOL:     0,
+    HEX:      16,
+    INT:      10,
+    STRING:   0,
+    TRISTATE: 0,
+    UNKNOWN:  0,
+}
+
+_RELATIONS = frozenset((
+    EQUAL,
+    UNEQUAL,
+    LESS,
+    LESS_EQUAL,
+    GREATER,
+    GREATER_EQUAL,
+))
+
+# Token to relation (=, !=, <, ...) mapping
+_TOKEN_TO_REL = {
+    _T_EQUAL:         EQUAL,
+    _T_GREATER:       GREATER,
+    _T_GREATER_EQUAL: GREATER_EQUAL,
+    _T_LESS:          LESS,
+    _T_LESS_EQUAL:    LESS_EQUAL,
+    _T_UNEQUAL:       UNEQUAL,
+}
+
+_REL_TO_STR = {
+    EQUAL:         "=",
+    GREATER:       ">",
+    GREATER_EQUAL: ">=",
+    LESS:          "<",
+    LESS_EQUAL:    "<=",
+    UNEQUAL:       "!=",
+}

From af526f2a5168eec56522e93f1b963c45f94fd75e Mon Sep 17 00:00:00 2001
From: Dong Heng <dongheng@espressif.com>
Date: Thu, 3 May 2018 16:26:26 +0800
Subject: [PATCH 3/5] chore(cmake): Add cmake tools

---
 tools/cmake/components.cmake                  | 165 +++++++++++++
 tools/cmake/convert_to_cmake.py               | 219 ++++++++++++++++++
 tools/cmake/crosstool_version_check.cmake     |  32 +++
 tools/cmake/git_submodules.cmake              |  61 +++++
 tools/cmake/idf_functions.cmake               | 203 ++++++++++++++++
 tools/cmake/kconfig.cmake                     | 130 +++++++++++
 tools/cmake/project.cmake                     | 140 +++++++++++
 tools/cmake/project_description.json.in       |  18 ++
 tools/cmake/run_cmake_lint.sh                 |  32 +++
 tools/cmake/scripts/data_file_embed_asm.cmake |  82 +++++++
 tools/cmake/scripts/expand_requirements.cmake | 216 +++++++++++++++++
 .../GetGitRevisionDescription.cmake           | 133 +++++++++++
 .../GetGitRevisionDescription.cmake.in        |  41 ++++
 tools/cmake/toolchain-esp32.cmake             |   7 +
 tools/cmake/utilities.cmake                   | 181 +++++++++++++++
 15 files changed, 1660 insertions(+)
 create mode 100644 tools/cmake/components.cmake
 create mode 100755 tools/cmake/convert_to_cmake.py
 create mode 100644 tools/cmake/crosstool_version_check.cmake
 create mode 100644 tools/cmake/git_submodules.cmake
 create mode 100644 tools/cmake/idf_functions.cmake
 create mode 100644 tools/cmake/kconfig.cmake
 create mode 100644 tools/cmake/project.cmake
 create mode 100644 tools/cmake/project_description.json.in
 create mode 100755 tools/cmake/run_cmake_lint.sh
 create mode 100644 tools/cmake/scripts/data_file_embed_asm.cmake
 create mode 100644 tools/cmake/scripts/expand_requirements.cmake
 create mode 100644 tools/cmake/third_party/GetGitRevisionDescription.cmake
 create mode 100644 tools/cmake/third_party/GetGitRevisionDescription.cmake.in
 create mode 100644 tools/cmake/toolchain-esp32.cmake
 create mode 100644 tools/cmake/utilities.cmake

diff --git a/tools/cmake/components.cmake b/tools/cmake/components.cmake
new file mode 100644
index 00000000..506d8a06
--- /dev/null
+++ b/tools/cmake/components.cmake
@@ -0,0 +1,165 @@
+# Given a list of components in 'component_paths', filter only paths to the components
+# mentioned in 'components' and return as a list in 'result_paths'
+function(components_get_paths component_paths components result_paths)
+    set(result "")
+    foreach(path ${component_paths})
+        get_filename_component(name "${path}" NAME)
+        if("${name}" IN_LIST components)
+            list(APPEND result "${name}")
+        endif()
+    endforeach()
+    set("${result_path}" "${result}" PARENT_SCOPE)
+endfunction()
+
+# Add a component to the build, using the COMPONENT variables defined
+# in the parent
+#
+function(register_component)
+    get_filename_component(component_dir ${CMAKE_CURRENT_LIST_FILE} DIRECTORY)
+    get_filename_component(component ${component_dir} NAME)
+
+    spaces2list(COMPONENT_SRCDIRS)
+    spaces2list(COMPONENT_ADD_INCLUDEDIRS)
+
+    # Add to COMPONENT_SRCS by globbing in COMPONENT_SRCDIRS
+    if(NOT COMPONENT_SRCS)
+        foreach(dir ${COMPONENT_SRCDIRS})
+            get_filename_component(abs_dir ${dir} ABSOLUTE BASE_DIR ${component_dir})
+            if(NOT IS_DIRECTORY ${abs_dir})
+                message(FATAL_ERROR "${CMAKE_CURRENT_LIST_FILE}: COMPONENT_SRCDIRS entry '${dir}' does not exist")
+            endif()
+
+            file(GLOB matches "${abs_dir}/*.c" "${abs_dir}/*.cpp" "${abs_dir}/*.S")
+            if(matches)
+                list(SORT matches)
+                set(COMPONENT_SRCS "${COMPONENT_SRCS};${matches}")
+            else()
+                message(FATAL_ERROR "${CMAKE_CURRENT_LIST_FILE}: COMPONENT_SRCDIRS entry '${dir}' has no source files")
+            endif()
+        endforeach()
+    endif()
+
+    # add as a PUBLIC library (if there are source files) or INTERFACE (if header only)
+    if(COMPONENT_SRCS OR embed_binaries)
+        add_library(${component} STATIC ${COMPONENT_SRCS})
+        set(include_type PUBLIC)
+    else()
+        add_library(${component} INTERFACE) # header-only component
+        set(include_type INTERFACE)
+    endif()
+
+    # binaries to embed directly in library
+    spaces2list(COMPONENT_EMBED_FILES)
+    spaces2list(COMPONENT_EMBED_TXTFILES)
+    foreach(embed_data ${COMPONENT_EMBED_FILES} ${COMPONENT_EMBED_TXTFILES})
+        if(embed_data IN_LIST COMPONENT_EMBED_TXTFILES)
+            set(embed_type "TEXT")
+        else()
+            set(embed_type "BINARY")
+        endif()
+        target_add_binary_data("${component}" "${embed_data}" "${embed_type}")
+    endforeach()
+
+    # add component public includes
+    foreach(include_dir ${COMPONENT_ADD_INCLUDEDIRS})
+        get_filename_component(abs_dir ${include_dir} ABSOLUTE BASE_DIR ${component_dir})
+        if(NOT IS_DIRECTORY ${abs_dir})
+            message(FATAL_ERROR "${CMAKE_CURRENT_LIST_FILE}: "
+                "COMPONENT_ADD_INCLUDEDIRS entry '${include_dir}' not found")
+        endif()
+        target_include_directories(${component} ${include_type} ${abs_dir})
+    endforeach()
+
+    # add component private includes
+    foreach(include_dir ${COMPONENT_PRIV_INCLUDEDIRS})
+        if(${include_type} STREQUAL INTERFACE)
+            message(FATAL_ERROR "${CMAKE_CURRENT_LIST_FILE} "
+                "sets no component source files but sets COMPONENT_PRIV_INCLUDEDIRS")
+        endif()
+
+        get_filename_component(abs_dir ${include_dir} ABSOLUTE BASE_DIR ${component_dir})
+        if(NOT IS_DIRECTORY ${abs_dir})
+            message(FATAL_ERROR "${CMAKE_CURRENT_LIST_FILE}: "
+                "COMPONENT_PRIV_INCLUDEDIRS entry '${include_dir}' does not exist")
+        endif()
+        target_include_directories(${component} PRIVATE ${abs_dir})
+    endforeach()
+endfunction()
+
+function(register_config_only_component)
+    get_filename_component(component_dir ${CMAKE_CURRENT_LIST_FILE} DIRECTORY)
+    get_filename_component(component ${component_dir} NAME)
+
+    # No-op for now...
+endfunction()
+
+function(add_component_dependencies target dep dep_type)
+    get_target_property(target_type ${target} TYPE)
+    get_target_property(target_imported ${target} IMPORTED)
+
+    if(${target_type} STREQUAL STATIC_LIBRARY OR ${target_type} STREQUAL EXECUTABLE)
+        if(TARGET ${dep})
+            # Add all compile options exported by dep into target
+            target_include_directories(${target} ${dep_type}
+                $<TARGET_PROPERTY:${dep},INTERFACE_INCLUDE_DIRECTORIES>)
+            target_compile_definitions(${target} ${dep_type}
+                $<TARGET_PROPERTY:${dep},INTERFACE_COMPILE_DEFINITIONS>)
+            target_compile_options(${target} ${dep_type}
+                $<TARGET_PROPERTY:${dep},INTERFACE_COMPILE_OPTIONS>)
+        endif()
+    endif()
+endfunction()
+
+function(components_finish_registration)
+
+    # have the executable target depend on all components in the build
+    set_target_properties(${CMAKE_PROJECT_NAME}.elf PROPERTIES INTERFACE_COMPONENT_REQUIRES "${BUILD_COMPONENTS}")
+
+    spaces2list(COMPONENT_REQUIRES_COMMON)
+
+    # each component should see the include directories of its requirements
+    #
+    # (we can't do this until all components are registered and targets exist in cmake, as we have
+    # a circular requirements graph...)
+    foreach(a ${BUILD_COMPONENTS})
+        if(TARGET ${a})
+            get_component_requirements("${a}" a_deps a_priv_deps)
+            list(APPEND a_priv_deps ${COMPONENT_REQUIRES_COMMON})
+            foreach(b ${a_deps})
+                add_component_dependencies(${a} ${b} PUBLIC)
+            endforeach()
+
+            foreach(b ${a_priv_deps})
+                add_component_dependencies(${a} ${b} PRIVATE)
+            endforeach()
+
+            get_target_property(a_type ${a} TYPE)
+            if(${a_type} MATCHES .+_LIBRARY)
+                set(COMPONENT_LIBRARIES "${COMPONENT_LIBRARIES};${a}")
+            endif()
+        endif()
+    endforeach()
+
+    # Add each component library's link-time dependencies (which are otherwise ignored) to the executable
+    # LINK_DEPENDS in order to trigger a re-link when needed (on Ninja/Makefile generators at least).
+    # (maybe this should probably be something CMake does, but it doesn't do it...)
+    foreach(component ${BUILD_COMPONENTS})
+        if(TARGET ${component})
+            get_target_property(imported ${component} IMPORTED)
+            get_target_property(type ${component} TYPE)
+            if(NOT imported)
+                if(${type} STREQUAL STATIC_LIBRARY OR ${type} STREQUAL EXECUTABLE)
+                    get_target_property(link_depends "${component}" LINK_DEPENDS)
+                    if(link_depends)
+                        set_property(TARGET ${CMAKE_PROJECT_NAME}.elf APPEND PROPERTY LINK_DEPENDS "${link_depends}")
+                    endif()
+                endif()
+            endif()
+        endif()
+    endforeach()
+
+    target_link_libraries(${CMAKE_PROJECT_NAME}.elf ${COMPONENT_LIBRARIES})
+
+    message(STATUS "Component libraries: ${COMPONENT_LIBRARIES}")
+
+endfunction()
diff --git a/tools/cmake/convert_to_cmake.py b/tools/cmake/convert_to_cmake.py
new file mode 100755
index 00000000..82e69717
--- /dev/null
+++ b/tools/cmake/convert_to_cmake.py
@@ -0,0 +1,219 @@
+#!/usr/bin/env python
+#
+# Command line tool to convert simple ESP-IDF Makefile & component.mk files to
+# CMakeLists.txt files
+#
+import argparse
+import subprocess
+import re
+import os.path
+import glob
+import sys
+
+debug = False
+
+def get_make_variables(path, makefile="Makefile", expected_failure=False, variables={}):
+    """
+    Given the path to a Makefile of some kind, return a dictionary of all variables defined in this Makefile
+
+    Uses 'make' to parse the Makefile syntax, so we don't have to!
+
+    Overrides IDF_PATH= to avoid recursively evaluating the entire project Makefile structure.
+    """
+    variable_setters = [ ("%s=%s" % (k,v)) for (k,v) in variables.items() ]
+
+    cmdline = ["make", "-rpn", "-C", path, "-f", makefile ] + variable_setters
+    if debug:
+        print("Running %s..." % (" ".join(cmdline)))
+
+    p = subprocess.Popen(cmdline, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    (output, stderr) = p.communicate("\n")
+
+    if (not expected_failure) and p.returncode != 0:
+        raise RuntimeError("Unexpected make failure, result %d" % p.returncode)
+
+    if debug:
+        print("Make stdout:")
+        print(output)
+        print("Make stderr:")
+        print(stderr)
+
+    next_is_makefile = False  # is the next line a makefile variable?
+    result = {}
+    BUILT_IN_VARS = set(["MAKEFILE_LIST", "SHELL", "CURDIR", "MAKEFLAGS"])
+
+    for line in output.decode().split("\n"):
+        if line.startswith("# makefile"):  # this line appears before any variable defined in the makefile itself
+            next_is_makefile = True
+        elif next_is_makefile:
+            next_is_makefile = False
+            m = re.match(r"(?P<var>[^ ]+) :?= (?P<val>.+)", line)
+            if m is not None:
+                if not m.group("var") in BUILT_IN_VARS:
+                    result[m.group("var")] = m.group("val").strip()
+
+    return result
+
+def get_component_variables(project_path, component_path):
+    make_vars = get_make_variables(component_path,
+                                   os.path.join(os.environ["IDF_PATH"],
+                                                "make",
+                                                "component_wrapper.mk"),
+                                   expected_failure=True,
+                                   variables = {
+                                       "COMPONENT_MAKEFILE" : os.path.join(component_path, "component.mk"),
+                                       "COMPONENT_NAME" : os.path.basename(component_path),
+                                       "PROJECT_PATH": project_path,
+                                   })
+
+    if "COMPONENT_OBJS" in make_vars:  # component.mk specifies list of object files
+        # Convert to sources
+        def find_src(obj):
+            obj = os.path.splitext(obj)[0]
+            for ext in [ "c", "cpp", "S" ]:
+                if os.path.exists(os.path.join(component_path, obj) + "." + ext):
+                    return obj + "." + ext
+            print("WARNING: Can't find source file for component %s COMPONENT_OBJS %s" % (component_path, obj))
+            return None
+
+        srcs = []
+        for obj in make_vars["COMPONENT_OBJS"].split(" "):
+            src = find_src(obj)
+            if src is not None:
+                srcs.append(src)
+        make_vars["COMPONENT_SRCS"] = " ".join(srcs)
+    else:  # Use COMPONENT_SRCDIRS
+        make_vars["COMPONENT_SRCDIRS"] = make_vars.get("COMPONENT_SRCDIRS", ".")
+
+    make_vars["COMPONENT_ADD_INCLUDEDIRS"] = make_vars.get("COMPONENT_ADD_INCLUDEDIRS", "include")
+
+    return make_vars
+
+
+def convert_project(project_path):
+    if not os.path.exists(project_path):
+        raise RuntimeError("Project directory '%s' not found" % project_path)
+    if not os.path.exists(os.path.join(project_path, "Makefile")):
+        raise RuntimeError("Directory '%s' doesn't contain a project Makefile" % project_path)
+
+    project_cmakelists = os.path.join(project_path, "CMakeLists.txt")
+    if os.path.exists(project_cmakelists):
+        raise RuntimeError("This project already has a CMakeLists.txt file")
+
+    project_vars = get_make_variables(project_path, expected_failure=True)
+    if not "PROJECT_NAME" in project_vars:
+        raise RuntimeError("PROJECT_NAME does not appear to be defined in IDF project Makefile at %s" % project_path)
+
+    component_paths = project_vars["COMPONENT_PATHS"].split(" ")
+
+    # "main" component is made special in cmake, so extract it from the component_paths list
+    try:
+        main_component_path = [ p for p in component_paths if os.path.basename(p) == "main" ][0]
+        if debug:
+            print("Found main component %s"  % main_component_path)
+        main_vars = get_component_variables(project_path, main_component_path)
+    except IndexError:
+        print("WARNING: Project has no 'main' component, but CMake-based system requires at least one file in MAIN_SRCS...")
+        main_vars = { "COMPONENT_SRCS" : ""} # dummy for MAIN_SRCS
+
+    # Remove main component from list of components we're converting to cmake
+    component_paths = [ p for p in component_paths if os.path.basename(p) != "main" ]
+
+    # Convert components as needed
+    for p in component_paths:
+        convert_component(project_path, p)
+
+    # Look up project variables before we start writing the file, so nothing
+    # is created if there is an error
+
+    main_srcs = main_vars["COMPONENT_SRCS"].split(" ")
+    # convert from component-relative to absolute paths
+    main_srcs = [ os.path.normpath(os.path.join(main_component_path, m)) for m in main_srcs ]
+    # convert to make relative to the project directory
+    main_srcs = [ os.path.relpath(m, project_path) for m in main_srcs ]
+
+    project_name = project_vars["PROJECT_NAME"]
+
+    # Generate the project CMakeLists.txt file
+    with open(project_cmakelists, "w") as f:
+        f.write("""
+# (Automatically converted from project Makefile by convert_to_cmake.py.)
+
+# The following four lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.5)
+
+""")
+        f.write("set(MAIN_SRCS %s)\n" % " ".join(main_srcs))
+        f.write("""
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+""")
+        f.write("project(%s)\n" % project_name)
+
+    print("Converted project %s" % project_cmakelists)
+
+def convert_component(project_path, component_path):
+    if debug:
+        print("Converting %s..." % (component_path))
+    cmakelists_path = os.path.join(component_path, "CMakeLists.txt")
+    if os.path.exists(cmakelists_path):
+        print("Skipping already-converted component %s..." % cmakelists_path)
+        return
+    v = get_component_variables(project_path, component_path)
+
+    # Look up all the variables before we start writing the file, so it's not
+    # created if there's an erro
+    component_srcs = v.get("COMPONENT_SRCS", None)
+    component_srcdirs = None
+    if component_srcs is not None:
+        # see if we should be using COMPONENT_SRCS or COMPONENT_SRCDIRS, if COMPONENT_SRCS is everything in SRCDIRS
+        component_allsrcs = []
+        for d in v.get("COMPONENT_SRCDIRS", "").split(" "):
+            component_allsrcs += glob.glob(os.path.normpath(os.path.join(component_path, d, "*.[cS]")))
+            component_allsrcs += glob.glob(os.path.normpath(os.path.join(component_path, d, "*.cpp")))
+        abs_component_srcs = [os.path.normpath(os.path.join(component_path, p)) for p in component_srcs.split(" ")]
+        if set(component_allsrcs) == set(abs_component_srcs):
+            component_srcdirs = v.get("COMPONENT_SRCDIRS")
+
+    component_add_includedirs = v["COMPONENT_ADD_INCLUDEDIRS"]
+    cflags = v.get("CFLAGS", None)
+
+    with open(cmakelists_path, "w") as f:
+        f.write("set(COMPONENT_ADD_INCLUDEDIRS %s)\n\n" % component_add_includedirs)
+
+        f.write("# Edit following two lines to set component requirements (see docs)\n")
+        f.write("set(COMPONENT_REQUIRES "")\n")
+        f.write("set(COMPONENT_PRIV_REQUIRES "")\n\n")
+
+        if component_srcdirs is not None:
+            f.write("set(COMPONENT_SRCDIRS %s)\n\n" % component_srcdirs)
+            f.write("register_component()\n")
+        elif component_srcs is not None:
+            f.write("set(COMPONENT_SRCS %s)\n\n" % component_srcs)
+            f.write("register_component()\n")
+        else:
+            f.write("register_config_only_component()\n")
+        if cflags is not None:
+            f.write("component_compile_options(%s)\n" % cflags)
+
+    print("Converted %s" % cmakelists_path)
+
+
+def main():
+    global debug
+
+    parser = argparse.ArgumentParser(description='convert_to_cmake.py - ESP-IDF Project Makefile to CMakeLists.txt converter', prog='convert_to_cmake')
+
+    parser.add_argument('--debug', help='Display debugging output',
+                        action='store_true')
+
+    parser.add_argument('project', help='Path to project to convert (defaults to CWD)', default=os.getcwd(), metavar='project path', nargs='?')
+
+    args = parser.parse_args()
+    debug = args.debug
+    print("Converting %s..." % args.project)
+    convert_project(args.project)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/cmake/crosstool_version_check.cmake b/tools/cmake/crosstool_version_check.cmake
new file mode 100644
index 00000000..d572a82a
--- /dev/null
+++ b/tools/cmake/crosstool_version_check.cmake
@@ -0,0 +1,32 @@
+# Function to check the toolchain used the expected version
+# of crosstool, and warn otherwise
+
+set(ctng_version_warning "Check Getting Started documentation or proceed at own risk.")
+
+function(gcc_version_check expected_gcc_version)
+    if(NOT "${CMAKE_C_COMPILER_VERSION}" STREQUAL "${expected_gcc_version}")
+        message(WARNING "Xtensa toolchain ${CMAKE_C_COMPILER} version ${CMAKE_C_COMPILER_VERSION} "
+            "is not the supported version ${expected_gcc_version}. ${ctng_version_warning}")
+    endif()
+endfunction()
+
+function(crosstool_version_check expected_ctng_version)
+    execute_process(
+        COMMAND ${CMAKE_C_COMPILER} -v
+        ERROR_VARIABLE toolchain_stderr
+        OUTPUT_QUIET)
+
+    string(REGEX MATCH "crosstool-ng-[0-9a-g\\.-]+" ctng_version "${toolchain_stderr}")
+    string(REPLACE "crosstool-ng-" "" ctng_version "${ctng_version}")
+    # We use FIND to match version instead of STREQUAL because some toolchains are built
+    # with longer git hash strings than others. This will match any version which starts with
+    # the expected version string.
+    string(FIND "${ctng_version}" "${expected_ctng_version}" found_expected_version)
+    if(NOT ctng_version)
+        message(WARNING "Xtensa toolchain ${CMAKE_C_COMPILER} does not appear to be built with crosstool-ng. "
+            "${ctng_version_warning}")
+    elseif(found_expected_version EQUAL -1)
+        message(WARNING "Xtensa toolchain ${CMAKE_C_COMPILER} crosstool-ng version ${ctng_version} "
+            "doesn't match supported version ${expected_ctng_version}. ${ctng_version_warning}")
+    endif()
+endfunction()
diff --git a/tools/cmake/git_submodules.cmake b/tools/cmake/git_submodules.cmake
new file mode 100644
index 00000000..09098b24
--- /dev/null
+++ b/tools/cmake/git_submodules.cmake
@@ -0,0 +1,61 @@
+find_package(Git)
+
+if(NOT GIT_FOUND)
+    message(WARNING "Git executable was not found. Git submodule checks will not be executed. "
+        "If you have any build issues at all, start by adding git executable to the PATH and "
+        "rerun cmake to not see this warning again.")
+
+    function(git_submodule_check root_path)
+        # no-op
+    endfunction()
+else()
+
+    function(git_submodule_check root_path)
+
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} submodule status
+            WORKING_DIRECTORY ${root_path}
+            OUTPUT_VARIABLE submodule_status
+            )
+
+        # git submodule status output not guaranteed to be stable,
+        # may need to check GIT_VERSION_STRING and do some fiddling in the
+        # future...
+
+        lines2list(submodule_status)
+
+        foreach(line ${submodule_status})
+            string(REGEX MATCH "(.)[0-9a-f]+ ([^\( ]+) ?" _ignored "${line}")
+            set(status "${CMAKE_MATCH_1}")
+            set(submodule_path "${CMAKE_MATCH_2}")
+
+            if("${status}" STREQUAL "-")  # missing submodule
+                message(STATUS "Initialising new submodule ${submodule_path}...")
+                execute_process(
+                    COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive ${submodule_path}
+                    WORKING_DIRECTORY ${root_path}
+                    RESULT_VARIABLE git_result
+                    )
+                if(git_result)
+                    message(FATAL_ERROR "Git submodule init failed for ${submodule_path}")
+                endif()
+
+            elseif(NOT "${status}" STREQUAL " ")
+                message(WARNING "Git submodule ${submodule_path} is out of date. "
+                    "Run 'git submodule update --init --recursive' to fix.")
+            endif()
+
+            # Force a re-run of cmake if the submodule's .git file changes or is changed (ie accidental deinit)
+            get_filename_component(submodule_abs_path ${submodule_path} ABSOLUTE BASE_DIR ${root_path})
+            set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${submodule_abs_path}/.git)
+            # same if the HEAD file in the submodule's directory changes (ie commit changes).
+            # This will at least print the 'out of date' warning
+            set(submodule_head "${root_path}/.git/modules/${submodule_path}/HEAD")
+            if(EXISTS "${submodule_head}")
+                set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${submodule_head})
+            endif()
+
+        endforeach()
+    endfunction()
+
+endif()
diff --git a/tools/cmake/idf_functions.cmake b/tools/cmake/idf_functions.cmake
new file mode 100644
index 00000000..3415f9da
--- /dev/null
+++ b/tools/cmake/idf_functions.cmake
@@ -0,0 +1,203 @@
+# Some IDF-specific functions and functions
+
+include(crosstool_version_check)
+
+#
+# Set some variables used by rest of the build
+#
+# Note at the time this macro is expanded, the config is not yet
+# loaded and the toolchain and project are not yet set
+#
+macro(idf_set_global_variables)
+    # Note that CONFIG_xxx is not available when this function is called
+
+    set_default(EXTRA_COMPONENT_DIRS "")
+
+    # Commmon components, required by every component in the build
+    #
+    set_default(COMPONENT_REQUIRES_COMMON "cxx esp32 newlib freertos heap log soc")
+
+    # PROJECT_PATH has the path to the IDF project (top-level cmake directory)
+    #
+    # (cmake calls this CMAKE_SOURCE_DIR, keeping old name for compatibility.)
+    set(PROJECT_PATH "${CMAKE_SOURCE_DIR}")
+
+    # Note: Unlike older build system, "main" is no longer a component. See build docs for details.
+    set_default(COMPONENT_DIRS "${PROJECT_PATH}/components ${EXTRA_COMPONENT_DIRS} ${IDF_PATH}/components")
+    spaces2list(COMPONENT_DIRS)
+
+    spaces2list(COMPONENTS)
+
+    # Tell cmake to drop executables in the top-level build dir
+    set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}")
+
+    # path to idf.py tool
+    set(IDFTOOL ${PYTHON} "${IDF_PATH}/tools/idf.py")
+endmacro()
+
+# Add all the IDF global compiler & preprocessor options
+# (applied to all components). Some are config-dependent
+#
+# If you only want to set options for a particular component,
+# don't call or edit this function. TODO DESCRIBE WHAT TO DO INSTEAD
+#
+function(idf_set_global_compiler_options)
+    add_definitions(-DESP_PLATFORM)
+    add_definitions(-DHAVE_CONFIG_H)
+
+    if(CONFIG_OPTIMIZATION_LEVEL_RELEASE)
+        add_compile_options(-Os)
+    else()
+        add_compile_options(-Og)
+    endif()
+
+    add_c_compile_options(-std=gnu99)
+
+    add_cxx_compile_options(-std=gnu++11 -fno-rtti)
+
+    if(CONFIG_CXX_EXCEPTIONS)
+        add_cxx_compile_options(-fexceptions)
+    else()
+        add_cxx_compile_options(-fno-exceptions)
+    endif()
+
+    # Default compiler configuration
+    add_compile_options(-ffunction-sections -fdata-sections -fstrict-volatile-bitfields -mlongcalls -nostdlib)
+
+    # Default warnings configuration
+    add_compile_options(
+        -Wall
+        -Werror=all
+        -Wno-error=unused-function
+        -Wno-error=unused-but-set-variable
+        -Wno-error=unused-variable
+        -Wno-error=deprecated-declarations
+        -Wextra
+        -Wno-unused-parameter
+        -Wno-sign-compare)
+    add_c_compile_options(
+        -Wno-old-style-declaration
+        )
+
+    # Stack protection
+    if(NOT BOOTLOADER_BUILD)
+        if(CONFIG_STACK_CHECK_NORM)
+            add_compile_options(-fstack-protector)
+        elseif(CONFIG_STACK_CHECK_STRONG)
+            add_compile_options(-fstack-protector-strong)
+        elseif(CONFIG_STACK_CHECK_ALL)
+            add_compile_options(-fstack-protector-all)
+        endif()
+    endif()
+
+    if(CONFIG_OPTIMIZATION_ASSERTIONS_DISABLED)
+        add_definitions(-DNDEBUG)
+    endif()
+
+    # Always generate debug symbols (even in Release mode, these don't
+    # go into the final binary so have no impact on size)
+    add_compile_options(-ggdb)
+
+    add_compile_options("-I${CMAKE_BINARY_DIR}") # for sdkconfig.h
+
+    # Enable ccache if it's on the path
+    if(NOT CCACHE_DISABLE)
+        find_program(CCACHE_FOUND ccache)
+        if(CCACHE_FOUND)
+            message(STATUS "ccache will be used for faster builds")
+            set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+        endif()
+    endif()
+
+endfunction()
+
+
+# Verify the IDF environment is configured correctly (environment, toolchain, etc)
+function(idf_verify_environment)
+
+    if(NOT CMAKE_PROJECT_NAME)
+        message(FATAL_ERROR "Internal error, IDF project.cmake should have set this variable already")
+    endif()
+
+    # Check toolchain is configured properly in cmake
+    if(NOT ( ${CMAKE_SYSTEM_NAME} STREQUAL "Generic" AND ${CMAKE_C_COMPILER} MATCHES xtensa))
+        message(FATAL_ERROR "Internal error, toolchain has not been set correctly by project")
+    endif()
+
+    #
+    # Warn if the toolchain version doesn't match
+    #
+    # TODO: make these platform-specific for diff toolchains
+    gcc_version_check("5.2.0")
+    crosstool_version_check("1.22.0-80-g6c4433a")
+
+endfunction()
+
+# idf_add_executable
+#
+# Calls add_executable to add the final project executable
+# Adds .map & .bin file targets
+# Sets up flash-related targets
+function(idf_add_executable)
+    set(exe_target ${PROJECT_NAME}.elf)
+
+    spaces2list(MAIN_SRCS)
+    add_executable(${exe_target} "${MAIN_SRCS}")
+
+    add_map_file(${exe_target})
+endfunction()
+
+
+# add_map_file
+#
+# Set linker args for 'exe_target' to generate a linker Map file
+function(add_map_file exe_target)
+    get_filename_component(basename ${exe_target} NAME_WE)
+    set(mapfile "${basename}.map")
+    target_link_libraries(${exe_target} "-Wl,--gc-sections -Wl,--cref -Wl,--Map=${mapfile} -Wl,--start-group")
+    set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" APPEND PROPERTY
+        ADDITIONAL_MAKE_CLEAN_FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/${mapfile}")
+
+    # add size targets, depend on map file, run idf_size.py
+    add_custom_target(size
+        DEPENDS ${exe_target}
+        COMMAND ${PYTHON} ${IDF_PATH}/tools/idf_size.py ${mapfile}
+        )
+    add_custom_target(size-files
+        DEPENDS ${exe_target}
+        COMMAND ${PYTHON} ${IDF_PATH}/tools/idf_size.py --files ${mapfile}
+        )
+    add_custom_target(size-components
+        DEPENDS ${exe_target}
+        COMMAND ${PYTHON} ${IDF_PATH}/tools/idf_size.py --archives ${mapfile}
+        )
+
+endfunction()
+
+# component_compile_options
+#
+# Wrapper around target_compile_options that passes the component name
+function(component_compile_options)
+    target_compile_options(${COMPONENT_NAME} PRIVATE ${ARGV})
+endfunction()
+
+# component_compile_definitions
+#
+# Wrapper around target_compile_definitions that passes the component name
+function(component_compile_definitions)
+    target_compile_definitions(${COMPONENT_NAME} PRIVATE ${ARGV})
+endfunction()
+
+# idf_get_git_revision
+#
+# Set global IDF_VER to the git revision of ESP-IDF.
+#
+# Running git_describe() here automatically triggers rebuilds
+# if the ESP-IDF git version changes
+function(idf_get_git_revision)
+    git_describe(IDF_VER "${IDF_PATH}")
+    add_definitions(-DIDF_VER=\"${IDF_VER}\")
+    git_submodule_check("${IDF_PATH}")
+    set(IDF_VER ${IDF_VER} PARENT_SCOPE)
+endfunction()
diff --git a/tools/cmake/kconfig.cmake b/tools/cmake/kconfig.cmake
new file mode 100644
index 00000000..eeb8ce11
--- /dev/null
+++ b/tools/cmake/kconfig.cmake
@@ -0,0 +1,130 @@
+include(ExternalProject)
+
+macro(kconfig_set_variables)
+    set_default(SDKCONFIG ${PROJECT_PATH}/sdkconfig)
+    set(SDKCONFIG_HEADER ${CMAKE_BINARY_DIR}/sdkconfig.h)
+    set(SDKCONFIG_CMAKE ${CMAKE_BINARY_DIR}/sdkconfig.cmake)
+    set(SDKCONFIG_JSON ${CMAKE_BINARY_DIR}/sdkconfig.json)
+
+    set(ROOT_KCONFIG ${IDF_PATH}/Kconfig)
+
+    set_default(SDKCONFIG_DEFAULTS "${SDKCONFIG}.defaults")
+endmacro()
+
+if(CMAKE_HOST_WIN32)
+    # Prefer a prebuilt mconf on Windows
+    find_program(WINPTY winpty)
+    find_program(MCONF mconf)
+
+    if(NOT MCONF)
+        find_program(NATIVE_GCC gcc)
+        if(NOT NATIVE_GCC)
+            message(FATAL_ERROR
+                "Windows requires a prebuilt ESP-IDF-specific mconf for your platform "
+                "on the PATH, or an MSYS2 version of gcc on the PATH to build mconf. "
+                "Consult the setup docs for ESP-IDF on Windows.")
+        endif()
+    elseif(WINPTY)
+        set(MCONF "${WINPTY}" "${MCONF}")
+    endif()
+endif()
+
+if(NOT MCONF)
+    # Use the existing Makefile to build mconf (out of tree) when needed
+    #
+    set(MCONF kconfig_bin/mconf)
+
+    externalproject_add(mconf
+        SOURCE_DIR ${IDF_PATH}/tools/kconfig
+        CONFIGURE_COMMAND ""
+        BINARY_DIR "kconfig_bin"
+        BUILD_COMMAND make -f ${IDF_PATH}/tools/kconfig/Makefile mconf
+        BUILD_BYPRODUCTS ${MCONF}
+        INSTALL_COMMAND ""
+        EXCLUDE_FROM_ALL 1
+        )
+    set(menuconfig_depends DEPENDS mconf)
+endif()
+
+# Find all Kconfig files for all components
+function(kconfig_process_config)
+    file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/include/config")
+    set(kconfigs)
+    set(kconfigs_projbuild)
+
+    # Find Kconfig and Kconfig.projbuild for each component as applicable
+    # if any of these change, cmake should rerun
+    foreach(dir ${BUILD_COMPONENT_PATHS} "${CMAKE_SOURCE_DIR}/main")
+        file(GLOB kconfig "${dir}/Kconfig")
+        if(kconfig)
+            set(kconfigs "${kconfigs} ${kconfig}")
+            set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${kconfig})
+        endif()
+        file(GLOB kconfig ${dir}/Kconfig.projbuild)
+        if(kconfig)
+            set(kconfigs_projbuild "${kconfigs_projbuild} ${kconfig}")
+            set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${kconfig})
+        endif()
+    endforeach()
+
+    if(EXISTS ${SDKCONFIG_DEFAULTS})
+        set(defaults_arg --defaults "${SDKCONFIG_DEFAULTS}")
+    endif()
+
+    # Set these in the parent scope, so that they can be written to project_description.json
+    set(kconfigs "${kconfigs}")
+    set(COMPONENT_KCONFIGS "${kconfigs}" PARENT_SCOPE)
+    set(COMPONENT_KCONFIGS_PROJBUILD "${kconfigs_projbuild}" PARENT_SCOPE)
+
+    set(confgen_basecommand
+        ${PYTHON} ${IDF_PATH}/tools/kconfig_new/confgen.py
+        --kconfig ${ROOT_KCONFIG}
+        --config ${SDKCONFIG}
+        ${defaults_arg}
+        --create-config-if-missing
+        --env "COMPONENT_KCONFIGS=${kconfigs}"
+        --env "COMPONENT_KCONFIGS_PROJBUILD=${kconfigs_projbuild}")
+
+    # Generate the menuconfig target (uses C-based mconf tool, either prebuilt or via mconf target above)
+    add_custom_target(menuconfig
+        ${menuconfig_depends}
+        # create any missing config file, with defaults if necessary
+        COMMAND ${confgen_basecommand} --output config ${SDKCONFIG}
+        COMMAND ${CMAKE_COMMAND} -E env
+        "COMPONENT_KCONFIGS=${kconfigs}"
+        "COMPONENT_KCONFIGS_PROJBUILD=${kconfigs_projbuild}"
+        "KCONFIG_CONFIG=${SDKCONFIG}"
+        ${MCONF} ${ROOT_KCONFIG}
+        VERBATIM
+        USES_TERMINAL)
+
+    # Generate configuration output via confgen.py
+    # makes sdkconfig.h and skdconfig.cmake
+    #
+    # This happens during the cmake run not during the build
+    execute_process(COMMAND ${confgen_basecommand}
+        --output header ${SDKCONFIG_HEADER}
+        --output cmake ${SDKCONFIG_CMAKE}
+        --output json ${SDKCONFIG_JSON}
+        RESULT_VARIABLE config_result)
+    if(config_result)
+        message(FATAL_ERROR "Failed to run confgen.py (${confgen_basecommand}). Error ${config_result}")
+    endif()
+
+    # When sdkconfig file changes in the future, trigger a cmake run
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${SDKCONFIG}")
+
+    # Ditto if either of the generated files are missing/modified (this is a bit irritating as it means
+    # you can't edit these manually without them being regenerated, but I don't know of a better way...)
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${SDKCONFIG_HEADER}")
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${SDKCONFIG_CMAKE}")
+
+    # Or if the config generation tool changes
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${IDF_PATH}/tools/kconfig_new/confgen.py")
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${IDF_PATH}/tools/kconfig_new/kconfiglib.py")
+
+    set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" APPEND PROPERTY
+        ADDITIONAL_MAKE_CLEAN_FILES
+        "${SDKCONFIG_HEADER}" "${SDKCONFIG_CMAKE}")
+
+endfunction()
diff --git a/tools/cmake/project.cmake b/tools/cmake/project.cmake
new file mode 100644
index 00000000..ff344a96
--- /dev/null
+++ b/tools/cmake/project.cmake
@@ -0,0 +1,140 @@
+# Designed to be included from an IDF app's CMakeLists.txt file
+#
+cmake_minimum_required(VERSION 3.5)
+
+# Set IDF_PATH, as nothing else will work without this
+set(IDF_PATH "$ENV{IDF_PATH}")
+if(NOT IDF_PATH)
+    # Documentation says you should set IDF_PATH in your environment, but we
+    # can infer it here if it's not set.
+    set(IDF_PATH ${CMAKE_CURRENT_LIST_DIR})
+endif()
+file(TO_CMAKE_PATH "${IDF_PATH}" IDF_PATH)
+set($ENV{IDF_PATH} "${IDF_PATH}")
+
+#
+# Load cmake modules
+#
+set(CMAKE_MODULE_PATH
+    "${IDF_PATH}/tools/cmake"
+    "${IDF_PATH}/tools/cmake/third_party"
+    ${CMAKE_MODULE_PATH})
+include(GetGitRevisionDescription)
+include(utilities)
+include(components)
+include(kconfig)
+include(git_submodules)
+include(idf_functions)
+
+set_default(PYTHON "python")
+
+# project
+#
+# This macro wraps the cmake 'project' command to add
+# all of the IDF-specific functionality required
+#
+# Implementation Note: This macro wraps 'project' on purpose, because cmake has
+# some backwards-compatible magic where if you don't call "project" in the
+# top-level CMakeLists file, it will call it implicitly. However, the implicit
+# project will not have CMAKE_TOOLCHAIN_FILE set and therefore tries to
+# create a native build project.
+#
+# Therefore, to keep all the IDF "build magic", the cleanest way is to keep the
+# top-level "project" call but customize it to do what we want in the IDF build.
+#
+macro(project name)
+    # Set global variables used by rest of the build
+    idf_set_global_variables()
+
+    # Establish dependencies for components in the build
+    # (this happens before we even generate config...)
+    if(COMPONENTS)
+        # Make sure if an explicit list of COMPONENTS is given, it contains the "common" component requirements
+        # (otherwise, if COMPONENTS is empty then all components will be included in the build.)
+        set(COMPONENTS "${COMPONENTS} ${COMPONENT_REQUIRES_COMMON}")
+    endif()
+    execute_process(COMMAND "${CMAKE_COMMAND}"
+        -D "COMPONENTS=${COMPONENTS}"
+        -D "DEPENDENCIES_FILE=${CMAKE_BINARY_DIR}/component_depends.cmake"
+        -D "COMPONENT_DIRS=${COMPONENT_DIRS}"
+        -D "BOOTLOADER_BUILD=${BOOTLOADER_BUILD}"
+        -P "${IDF_PATH}/tools/cmake/scripts/expand_requirements.cmake"
+        WORKING_DIRECTORY "${IDF_PATH}/tools/cmake")
+    include("${CMAKE_BINARY_DIR}/component_depends.cmake")
+
+    # We now have the following component-related variables:
+    # COMPONENTS is the list of initial components set by the user (or empty to include all components in the build).
+    # BUILD_COMPONENTS is the list of components to include in the build.
+    # BUILD_COMPONENT_PATHS is the paths to all of these components.
+
+    # Print list of components
+    string(REPLACE ";" " " BUILD_COMPONENTS_SPACES "${BUILD_COMPONENTS}")
+    message(STATUS "Component names: ${BUILD_COMPONENTS_SPACES}")
+    unset(BUILD_COMPONENTS_SPACES)
+    message(STATUS "Component paths: ${BUILD_COMPONENT_PATHS}")
+
+    kconfig_set_variables()
+
+    kconfig_process_config()
+
+    # Include sdkconfig.cmake so rest of the build knows the configuration
+    include(${SDKCONFIG_CMAKE})
+
+    # Now the configuration is loaded, set the toolchain appropriately
+    #
+    # TODO: support more toolchains than just ESP32
+    set(CMAKE_TOOLCHAIN_FILE $ENV{IDF_PATH}/tools/cmake/toolchain-esp32.cmake)
+
+    # Declare the actual cmake-level project
+    _project(${name} ASM C CXX)
+
+    # generate compile_commands.json (needs to come after project)
+    set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
+
+    # Verify the environment is configured correctly
+    idf_verify_environment()
+
+    # Add some idf-wide definitions
+    idf_set_global_compiler_options()
+
+    # Check git revision (may trigger reruns of cmake)
+    ##  sets IDF_VER to IDF git revision
+    idf_get_git_revision()
+    ## if project uses git, retrieve revision
+    git_describe(PROJECT_VER "${CMAKE_CURRENT_SOURCE_DIR}")
+
+    # Include any top-level project_include.cmake files from components
+    foreach(component ${BUILD_COMPONENT_PATHS})
+        include_if_exists("${component}/project_include.cmake")
+    endforeach()
+
+    #
+    # Add each component to the build as a library
+    #
+    foreach(COMPONENT_PATH ${BUILD_COMPONENT_PATHS})
+        get_filename_component(COMPONENT_NAME ${COMPONENT_PATH} NAME)
+        add_subdirectory(${COMPONENT_PATH} ${COMPONENT_NAME})
+    endforeach()
+    unset(COMPONENT_NAME)
+    unset(COMPONENT_PATH)
+
+    #
+    # Add the app executable to the build (has name of PROJECT.elf)
+    #
+    idf_add_executable()
+
+    # Write project description JSON file
+    make_json_list("${BUILD_COMPONENTS}" build_components_json)
+    make_json_list("${BUILD_COMPONENT_PATHS}" build_component_paths_json)
+    configure_file("${IDF_PATH}/tools/cmake/project_description.json.in"
+        "${CMAKE_BINARY_DIR}/project_description.json")
+    unset(build_components_json)
+    unset(build_component_paths_json)
+
+    #
+    # Finish component registration (add cross-dependencies, make
+    # executable dependent on all components)
+    #
+    components_finish_registration()
+
+endmacro()
diff --git a/tools/cmake/project_description.json.in b/tools/cmake/project_description.json.in
new file mode 100644
index 00000000..878dce3b
--- /dev/null
+++ b/tools/cmake/project_description.json.in
@@ -0,0 +1,18 @@
+{
+    "project_name":       "${PROJECT_NAME}",
+    "project_path":       "${PROJECT_PATH}",
+    "build_dir":          "${CMAKE_BINARY_DIR}",
+    "config_file":        "${SDKCONFIG}",
+    "config_defaults":    "${SDKCONFIG_DEFAULTS}",
+    "app_elf":            "${PROJECT_NAME}.elf",
+    "app_bin":            "${PROJECT_NAME}.bin",
+    "git_revision":       "${IDF_VER}",
+    "phy_data_partition": "${CONFIG_ESP32_PHY_INIT_DATA_IN_PARTITION}",
+    "monitor_baud" : "${CONFIG_MONITOR_BAUD}",
+    "config_environment" : {
+        "COMPONENT_KCONFIGS" : "${COMPONENT_KCONFIGS}",
+        "COMPONENT_KCONFIGS_PROJBUILD" : "${COMPONENT_KCONFIGS_PROJBUILD}"
+    },
+    "build_components" : ${build_components_json},
+    "build_component_paths" : ${build_component_paths_json}
+}
diff --git a/tools/cmake/run_cmake_lint.sh b/tools/cmake/run_cmake_lint.sh
new file mode 100755
index 00000000..65f49eed
--- /dev/null
+++ b/tools/cmake/run_cmake_lint.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+#
+# Run cmakelint on all cmake files in IDF_PATH (except third party)
+#
+# cmakelint: https://github.com/richq/cmake-lint
+#
+# NOTE: This script makes use of features in (currently unreleased)
+# cmakelint >1.4. Install directly from github as follows:
+#
+# pip install https://github.com/richq/cmake-lint/archive/058c6c0ed2536.zip
+#
+
+if [ -z "${IDF_PATH}" ]; then
+    echo "IDF_PATH variable needs to be set"
+    exit 3
+fi
+
+# exclusions include some third-party directories which contain upstream
+# CMakeLists files
+find ${IDF_PATH} \
+     -name build -prune \
+     -o -name third_party -prune \
+     \
+     -o -name 'nghttp2' -prune \
+     -o -name 'cJSON' -prune \
+     -o -name 'Findsodium.cmake' -prune \
+     \
+     -o -name CMakeLists.txt -print0 \
+     -o -name '*.cmake' -print0 \
+    | xargs -0 cmakelint --linelength=120 --spaces=4
+
+
diff --git a/tools/cmake/scripts/data_file_embed_asm.cmake b/tools/cmake/scripts/data_file_embed_asm.cmake
new file mode 100644
index 00000000..71329ade
--- /dev/null
+++ b/tools/cmake/scripts/data_file_embed_asm.cmake
@@ -0,0 +1,82 @@
+#
+# Convert a file (text or binary) into an assembler source file suitable
+# for gcc. Designed to replicate 'objcopy' with more predictable
+# naming, and supports appending a null byte for embedding text as
+# a string.
+#
+# Designed to be run as a script with "cmake -P"
+#
+# Set variables DATA_FILE, SOURCE_FILE, FILE_TYPE when running this.
+#
+# If FILE_TYPE is set to TEXT, a null byte is appended to DATA_FILE's contents
+# before SOURCE_FILE is created.
+#
+# If FILE_TYPE is unset (or any other value), DATA_FILE is copied
+# verbatim into SOURCE_FILE.
+#
+#
+if(NOT DATA_FILE)
+    message(FATAL_ERROR "DATA_FILE for converting must be specified")
+endif()
+
+if(NOT SOURCE_FILE)
+    message(FATAL_ERROR "SOURCE_FILE destination must be specified")
+endif()
+
+file(READ "${DATA_FILE}" data HEX)
+
+string(LENGTH "${data}" data_len)
+math(EXPR data_len "${data_len} / 2")  # 2 hex bytes per byte
+
+if(FILE_TYPE STREQUAL "TEXT")
+    set(data "${data}00")  # null-byte termination
+endif()
+
+## Convert string of raw hex bytes to lines of hex bytes as gcc .byte expressions
+string(REGEX REPLACE "................................" ".byte \\0\n" data "${data}")  # 16 bytes per line
+string(REGEX REPLACE "[^\n]+$" ".byte \\0\n" data "${data}")                           # last line
+string(REGEX REPLACE "[0-9a-f][0-9a-f]" "0x\\0, " data "${data}")                      # hex formatted C bytes
+string(REGEX REPLACE ", \n" "\n" data "${data}")                                       # trim the last comma
+
+## Come up with C-friendly symbol name based on source file
+get_filename_component(source_filename "${DATA_FILE}" NAME)
+string(MAKE_C_IDENTIFIER "${source_filename}" varname)
+
+function(append str)
+    file(APPEND "${SOURCE_FILE}" "${str}")
+endfunction()
+
+function(append_line str)
+    append("${str}\n")
+endfunction()
+
+function(append_identifier symbol)
+append_line("\n.global ${symbol}")
+append("${symbol}:")
+if(${ARGC} GREATER 1) # optional comment
+    append(" /* ${ARGV1} */")
+endif()
+append("\n")
+endfunction()
+
+file(WRITE "${SOURCE_FILE}" "/*")
+append_line(" * Data converted from ${DATA_FILE}")
+if(FILE_TYPE STREQUAL "TEXT")
+    append_line(" * (null byte appended)")
+endif()
+append_line(" */")
+
+append_line(".data")
+append_identifier("${varname}")
+append_identifier("_binary_${varname}_start" "for objcopy compatibility")
+append("${data}")
+
+append_identifier("_binary_${varname}_end" "for objcopy compatibility")
+
+append_line("")
+if(FILE_TYPE STREQUAL "TEXT")
+    append_identifier("${varname}_length" "not including null byte")
+else()
+    append_identifier("${varname}_length")
+endif()
+append_line(".word ${data_len}")
diff --git a/tools/cmake/scripts/expand_requirements.cmake b/tools/cmake/scripts/expand_requirements.cmake
new file mode 100644
index 00000000..9b56cf09
--- /dev/null
+++ b/tools/cmake/scripts/expand_requirements.cmake
@@ -0,0 +1,216 @@
+# expand_requires.cmake is a utility cmake script to expand component requirements early in the build,
+# before the components are ready to be included.
+#
+# Parameters:
+# - COMPONENTS = Space-separated list of initial components to include in the build.
+#   Can be empty, in which case all components are in the build.
+# - DEPENDENCIES_FILE = Path of generated cmake file which will contain the expanded dependencies for these
+#   components.
+# - COMPONENT_DIRS = List of paths to search for all components.
+# - DEBUG = Set -DDEBUG=1 to debug component lists in the build.
+#
+# If successful, DEPENDENCIES_FILE can be expanded to set BUILD_COMPONENTS & BUILD_COMPONENT_PATHS with all
+# components required for the build, and the get_component_requirements() function to return each component's
+# recursively expanded requirements.
+#
+# TODO: Error out if a component requirement is missing
+cmake_minimum_required(VERSION 3.5)
+include("utilities.cmake")
+
+if(NOT DEPENDENCIES_FILE)
+    message(FATAL_ERROR "DEPENDENCIES_FILE must be set.")
+endif()
+
+if(NOT COMPONENT_DIRS)
+    message(FATAL_ERROR "COMPONENT_DIRS variable must be set")
+endif()
+spaces2list(COMPONENT_DIRS)
+
+function(debug message)
+    if(DEBUG)
+        message(STATUS "${message}")
+    endif()
+endfunction()
+
+# Dummy register_component used to save requirements variables as global properties, for later expansion
+#
+# (expand_component_requirements() includes the component CMakeLists.txt, which then sets its component variables,
+# calls this dummy macro, and immediately exits again.)
+macro(register_component)
+    spaces2list(COMPONENT_REQUIRES)
+    set_property(GLOBAL PROPERTY "${COMPONENT}_REQUIRES" "${COMPONENT_REQUIRES}")
+    spaces2list(COMPONENT_PRIV_REQUIRES)
+    set_property(GLOBAL PROPERTY "${COMPONENT}_PRIV_REQUIRES" "${COMPONENT_PRIV_REQUIRES}")
+
+    # This is tricky: we override register_component() so it returns out of the component CMakeLists.txt
+    # (as we're declaring it as a macro not a function, so it doesn't have its own scope.)
+    #
+    # This means no targets are defined, and the component expansion ends early.
+    return()
+endmacro()
+
+macro(register_config_only_component)
+    register_component()
+endmacro()
+
+# Given a component name (find_name) and a list of component paths (component_paths),
+# return the path to the component in 'variable'
+#
+# Fatal error is printed if the component is not found.
+function(find_component_path find_name component_paths variable)
+    foreach(path ${component_paths})
+        get_filename_component(name "${path}" NAME)
+        if("${name}" STREQUAL "${find_name}")
+            set("${variable}" "${path}" PARENT_SCOPE)
+            return()
+        endif()
+    endforeach()
+    # TODO: find a way to print the dependency chain that lead to this not-found component
+    message(WARNING "Required component ${find_name} is not found in any of the provided COMPONENT_DIRS")
+endfunction()
+
+# components_find_all: Search 'component_dirs' for components and return them
+# as a list of names in 'component_names' and a list of full paths in
+# 'component_paths'
+#
+# component_paths contains only unique component names. Directories
+# earlier in the component_dirs list take precedence.
+function(components_find_all component_dirs component_paths component_names)
+    # component_dirs entries can be files or lists of files
+    set(paths "")
+    set(names "")
+
+    # start by expanding the component_dirs list with all subdirectories
+    foreach(dir ${component_dirs})
+        # Iterate any subdirectories for values
+        file(GLOB subdirs LIST_DIRECTORIES true "${dir}/*")
+        foreach(subdir ${subdirs})
+            set(component_dirs "${component_dirs};${subdir}")
+        endforeach()
+    endforeach()
+
+    # Look for a component in each component_dirs entry
+    foreach(dir ${component_dirs})
+        file(GLOB component "${dir}/CMakeLists.txt")
+        if(component)
+            get_filename_component(component "${component}" DIRECTORY)
+            get_filename_component(name "${component}" NAME)
+            if(NOT name IN_LIST names)
+                set(names "${names};${name}")
+                set(paths "${paths};${component}")
+            endif()
+
+        else()  # no CMakeLists.txt file
+            # test for legacy component.mk and warn
+            file(GLOB legacy_component "${dir}/component.mk")
+            if(legacy_component)
+                get_filename_component(legacy_component "${legacy_component}" DIRECTORY)
+                message(WARNING "Component ${legacy_component} contains old-style component.mk but no CMakeLists.txt. "
+                    "Component will be skipped.")
+            endif()
+        endif()
+
+    endforeach()
+
+    set(${component_paths} ${paths} PARENT_SCOPE)
+    set(${component_names} ${names} PARENT_SCOPE)
+endfunction()
+
+# expand_component_requirements: Recursively expand a component's requirements,
+# setting global properties BUILD_COMPONENTS & BUILD_COMPONENT_PATHS and
+# also invoking the components to call register_component() above,
+# which will add per-component global properties with dependencies, etc.
+function(expand_component_requirements component)
+    get_property(build_components GLOBAL PROPERTY BUILD_COMPONENTS)
+    if(${component} IN_LIST build_components)
+        return()  # already added this component
+    endif()
+
+    find_component_path("${component}" "${ALL_COMPONENT_PATHS}" component_path)
+    debug("Expanding dependencies of ${component} @ ${component_path}")
+    if(NOT component_path)
+        set_property(GLOBAL APPEND PROPERTY COMPONENTS_NOT_FOUND ${component})
+        return()
+    endif()
+
+    # include the component CMakeLists.txt to expand its properties
+    # into the global cache (via register_component(), above)
+    unset(COMPONENT_REQUIRES)
+    unset(COMPONENT_PRIV_REQUIRES)
+    set(COMPONENT ${component})
+    include(${component_path}/CMakeLists.txt)
+
+    set_property(GLOBAL APPEND PROPERTY BUILD_COMPONENT_PATHS ${component_path})
+    set_property(GLOBAL APPEND PROPERTY BUILD_COMPONENTS ${component})
+
+    get_property(requires GLOBAL PROPERTY "${component}_REQUIRES")
+    get_property(requires_priv GLOBAL PROPERTY "${component}_PRIV_REQUIRES")
+    foreach(req ${requires} ${requires_priv})
+        expand_component_requirements(${req})
+    endforeach()
+endfunction()
+
+
+# Main functionality goes here
+
+# Find every available component in COMPONENT_DIRS, save as ALL_COMPONENT_PATHS and ALL_COMPONENTS
+components_find_all("${COMPONENT_DIRS}" ALL_COMPONENT_PATHS ALL_COMPONENTS)
+
+if(NOT COMPONENTS)
+    set(COMPONENTS "${ALL_COMPONENTS}")
+endif()
+spaces2list(COMPONENTS)
+
+debug("ALL_COMPONENT_PATHS ${ALL_COMPONENT_PATHS}")
+debug("ALL_COMPONENTS ${ALL_COMPONENTS}")
+
+set_property(GLOBAL PROPERTY BUILD_COMPONENTS "")
+set_property(GLOBAL PROPERTY BUILD_COMPONENT_PATHS "")
+set_property(GLOBAL PROPERTY COMPONENTS_NOT_FOUND "")
+
+foreach(component ${COMPONENTS})
+    debug("Expanding initial component ${component}")
+    expand_component_requirements(${component})
+endforeach()
+
+get_property(build_components GLOBAL PROPERTY BUILD_COMPONENTS)
+get_property(build_component_paths GLOBAL PROPERTY BUILD_COMPONENT_PATHS)
+get_property(not_found GLOBAL PROPERTY COMPONENTS_NOT_FOUND)
+
+debug("components in build: ${build_components}")
+debug("components in build: ${build_component_paths}")
+debug("components not found: ${not_found}")
+
+function(line contents)
+    file(APPEND "${DEPENDENCIES_FILE}" "${contents}\n")
+endfunction()
+
+file(WRITE "${DEPENDENCIES_FILE}" "# Component requirements generated by expand_requirements.cmake\n\n")
+line("set(BUILD_COMPONENTS ${build_components})")
+line("set(BUILD_COMPONENT_PATHS ${build_component_paths})")
+line("")
+
+line("# get_component_requirements: Generated function to read the dependencies of a given component.")
+line("#")
+line("# Parameters:")
+line("# - component: Name of component")
+line("# - var_requires: output variable name. Set to recursively expanded COMPONENT_REQUIRES ")
+line("#   for this component.")
+line("# - var_private_requires: output variable name. Set to recursively expanded COMPONENT_PRIV_REQUIRES ")
+line("#   for this component.")
+line("#")
+line("# Throws a fatal error if 'componeont' is not found (indicates a build system problem).")
+line("#")
+line("function(get_component_requirements component var_requires var_private_requires)")
+foreach(build_component ${build_components})
+    get_property(reqs GLOBAL PROPERTY "${build_component}_REQUIRES")
+    get_property(private_reqs GLOBAL PROPERTY "${build_component}_PRIV_REQUIRES")
+    line("  if(\"\$\{component}\" STREQUAL \"${build_component}\")")
+    line("    set(\${var_requires} \"${reqs}\" PARENT_SCOPE)")
+    line("    set(\${var_private_requires} \"${private_reqs}\" PARENT_SCOPE)")
+    line("    return()")
+    line("  endif()")
+endforeach()
+
+line("  message(FATAL_ERROR \"Component not found: \${component}\")")
+line("endfunction()")
diff --git a/tools/cmake/third_party/GetGitRevisionDescription.cmake b/tools/cmake/third_party/GetGitRevisionDescription.cmake
new file mode 100644
index 00000000..6c711bbd
--- /dev/null
+++ b/tools/cmake/third_party/GetGitRevisionDescription.cmake
@@ -0,0 +1,133 @@
+# - Returns a version string from Git
+#
+# These functions force a re-configure on each git commit so that you can
+# trust the values of the variables in your build system.
+#
+#  get_git_head_revision(<refspecvar> <hashvar> <repo dir> [<additional arguments to git describe> ...])
+#
+# Returns the refspec and sha hash of the current head revision
+#
+#  git_describe(<var> <repo dir> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the source tree, and adjusting
+# the output so that it tests false if an error occurs.
+#
+#  git_get_exact_tag(<var> <repo dir> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe --exact-match on the source tree,
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+# Updated 2018 Espressif Systems to add _repo_dir argument
+# to get revision of other repositories
+
+if(__get_git_revision_description)
+	return()
+endif()
+set(__get_git_revision_description YES)
+
+# We must run the following at "include" time, not at function call time,
+# to find the path to this module rather than the path to a calling list file
+get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+function(get_git_head_revision _refspecvar _hashvar _repo_dir)
+    set(GIT_PARENT_DIR "${_repo_dir}")
+	set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+	while(NOT EXISTS "${GIT_DIR}")	# .git dir not found, search parent directories
+		set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
+		get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
+		if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
+			# We have reached the root directory, we are not in git
+			set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+			set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+			return()
+		endif()
+		set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+	endwhile()
+	# check if this is a submodule
+	if(NOT IS_DIRECTORY ${GIT_DIR})
+		file(READ ${GIT_DIR} submodule)
+		string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_RELATIVE ${submodule})
+		get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
+		get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE)
+	endif()
+	set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+	if(NOT EXISTS "${GIT_DATA}")
+		file(MAKE_DIRECTORY "${GIT_DATA}")
+	endif()
+
+	if(NOT EXISTS "${GIT_DIR}/HEAD")
+		return()
+	endif()
+	set(HEAD_FILE "${GIT_DATA}/HEAD")
+	configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY)
+
+	configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
+		"${GIT_DATA}/grabRef.cmake"
+		@ONLY)
+	include("${GIT_DATA}/grabRef.cmake")
+
+	set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE)
+	set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE)
+endfunction()
+
+function(git_describe _var _repo_dir)
+	if(NOT GIT_FOUND)
+		find_package(Git QUIET)
+	endif()
+	get_git_head_revision(refspec hash "${_repo_dir}")
+	if(NOT GIT_FOUND)
+		set(${_var} "GIT-NOTFOUND" PARENT_SCOPE)
+		return()
+	endif()
+	if(NOT hash)
+		set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE)
+		return()
+	endif()
+
+	# TODO sanitize
+	#if((${ARGN}" MATCHES "&&") OR
+	#	(ARGN MATCHES "||") OR
+	#	(ARGN MATCHES "\\;"))
+	#	message("Please report the following error to the project!")
+	#	message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+	#endif()
+
+	#message(STATUS "Arguments to execute_process: ${ARGN}")
+
+	execute_process(COMMAND
+		"${GIT_EXECUTABLE}"
+		describe
+		${hash}
+		${ARGN}
+		WORKING_DIRECTORY
+		"${CMAKE_CURRENT_SOURCE_DIR}"
+		RESULT_VARIABLE
+		res
+		OUTPUT_VARIABLE
+		out
+		ERROR_QUIET
+		OUTPUT_STRIP_TRAILING_WHITESPACE)
+	if(NOT res EQUAL 0)
+		set(out "${out}-${res}-NOTFOUND")
+	endif()
+
+	set(${_var} "${out}" PARENT_SCOPE)
+endfunction()
+
+function(git_get_exact_tag _var _repo_dir)
+	git_describe(out "${_repo_dir}" --exact-match ${ARGN})
+	set(${_var} "${out}" PARENT_SCOPE)
+endfunction()
diff --git a/tools/cmake/third_party/GetGitRevisionDescription.cmake.in b/tools/cmake/third_party/GetGitRevisionDescription.cmake.in
new file mode 100644
index 00000000..6d8b708e
--- /dev/null
+++ b/tools/cmake/third_party/GetGitRevisionDescription.cmake.in
@@ -0,0 +1,41 @@
+#
+# Internal file for GetGitRevisionDescription.cmake
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+set(HEAD_HASH)
+
+file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
+
+string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
+if(HEAD_CONTENTS MATCHES "ref")
+	# named branch
+	string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
+	if(EXISTS "@GIT_DIR@/${HEAD_REF}")
+		configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+	else()
+		configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
+		file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
+		if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
+			set(HEAD_HASH "${CMAKE_MATCH_1}")
+		endif()
+	endif()
+else()
+	# detached HEAD
+	configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
+endif()
+
+if(NOT HEAD_HASH)
+	file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+	string(STRIP "${HEAD_HASH}" HEAD_HASH)
+endif()
diff --git a/tools/cmake/toolchain-esp32.cmake b/tools/cmake/toolchain-esp32.cmake
new file mode 100644
index 00000000..c23fa4cb
--- /dev/null
+++ b/tools/cmake/toolchain-esp32.cmake
@@ -0,0 +1,7 @@
+set(CMAKE_SYSTEM_NAME Generic)
+
+set(CMAKE_C_COMPILER xtensa-esp32-elf-gcc)
+set(CMAKE_CXX_COMPILER xtensa-esp32-elf-g++)
+set(CMAKE_ASM_COMPILER xtensa-esp32-elf-gcc)
+
+set(CMAKE_EXE_LINKER_FLAGS "-nostdlib" CACHE STRING "Linker Base Flags")
diff --git a/tools/cmake/utilities.cmake b/tools/cmake/utilities.cmake
new file mode 100644
index 00000000..791e3fbf
--- /dev/null
+++ b/tools/cmake/utilities.cmake
@@ -0,0 +1,181 @@
+# set_default
+#
+# Define a variable to a default value if otherwise unset.
+#
+# Priority for new value is:
+# - Existing cmake value (ie set with cmake -D, or already set in CMakeLists)
+# - Value of any non-empty environment variable of the same name
+# - Default value as provided to function
+#
+function(set_default variable default_value)
+    if(NOT ${variable})
+        if($ENV{${variable}})
+            set(${variable} $ENV{${variable}} PARENT_SCOPE)
+        else()
+            set(${variable} ${default_value} PARENT_SCOPE)
+        endif()
+    endif()
+endfunction()
+
+# spaces2list
+#
+# Take a variable whose value was space-delimited values, convert to a cmake
+# list (semicolon-delimited)
+#
+# Note: if using this for directories, keeps the issue in place that
+# directories can't contain spaces...
+#
+# TODO: look at cmake separate_arguments, which is quote-aware
+function(spaces2list variable_name)
+    string(REPLACE " " ";" tmp "${${variable_name}}")
+    set("${variable_name}" "${tmp}" PARENT_SCOPE)
+endfunction()
+
+
+# lines2list
+#
+# Take a variable with multiple lines of output in it, convert it
+# to a cmake list (semicolon-delimited), one line per item
+#
+function(lines2list variable_name)
+    string(REGEX REPLACE "\r?\n" ";" tmp "${${variable_name}}")
+    string(REGEX REPLACE ";;" ";" tmp "${tmp}")
+    set("${variable_name}" "${tmp}" PARENT_SCOPE)
+endfunction()
+
+
+# move_if_different
+#
+# If 'source' has different md5sum to 'destination' (or destination
+# does not exist, move it across.
+#
+# If 'source' has the same md5sum as 'destination', delete 'source'.
+#
+# Avoids timestamp updates for re-generated files where content hasn't
+# changed.
+function(move_if_different source destination)
+    set(do_copy 1)
+    file(GLOB dest_exists ${destination})
+    if(dest_exists)
+        file(MD5 ${source} source_md5)
+        file(MD5 ${destination} dest_md5)
+        if(source_md5 STREQUAL dest_md5)
+            set(do_copy "")
+        endif()
+    endif()
+
+    if(do_copy)
+        message("Moving ${source} -> ${destination}")
+        file(RENAME ${source} ${destination})
+    else()
+        message("Not moving ${source} -> ${destination}")
+        file(REMOVE ${source})
+    endif()
+
+endfunction()
+
+
+# add_compile_options variant for C++ code only
+#
+# This adds global options, set target properties for
+# component-specific flags
+function(add_cxx_compile_options)
+    foreach(option ${ARGV})
+        # note: the Visual Studio Generator doesn't support this...
+        add_compile_options($<$<COMPILE_LANGUAGE:CXX>:${option}>)
+    endforeach()
+endfunction()
+
+# add_compile_options variant for C code only
+#
+# This adds global options, set target properties for
+# component-specific flags
+function(add_c_compile_options)
+    foreach(option ${ARGV})
+        # note: the Visual Studio Generator doesn't support this...
+        add_compile_options($<$<COMPILE_LANGUAGE:C>:${option}>)
+    endforeach()
+endfunction()
+
+
+# target_add_binary_data adds binary data into the built target,
+# by converting it to a generated source file which is then compiled
+# to a binary object as part of the build
+function(target_add_binary_data target embed_file embed_type)
+
+    get_filename_component(embed_file "${embed_file}" ABSOLUTE)
+
+    get_filename_component(name "${embed_file}" NAME)
+    set(embed_srcfile "${CMAKE_BINARY_DIR}/${name}.S")
+
+    add_custom_command(OUTPUT "${embed_srcfile}"
+        COMMAND "${CMAKE_COMMAND}"
+        -D "DATA_FILE=${embed_file}"
+        -D "SOURCE_FILE=${embed_srcfile}"
+        -D "FILE_TYPE=${embed_type}"
+        -P "${IDF_PATH}/tools/cmake/scripts/data_file_embed_asm.cmake"
+        MAIN_DEPENDENCY "${embed_file}"
+        DEPENDENCIES "${IDF_PATH}/tools/cmake/scripts/data_file_embed_asm.cmake"
+        WORKING_DIRECTORY "${CMAKE_BINARY_DIR}")
+
+    set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES "${embed_srcfile}")
+
+    target_sources("${target}" PRIVATE "${embed_srcfile}")
+endfunction()
+
+macro(include_if_exists path)
+    if(EXISTS "${path}")
+        include("${path}")
+    endif()
+endmacro()
+
+# Append a single line to the file specified
+# The line ending is determined by the host OS
+function(file_append_line file line)
+    if(ENV{MSYSTEM} OR CMAKE_HOST_WIN32)
+        set(line_ending "\r\n")
+    else() # unix
+        set(line_ending "\n")
+    endif()
+    file(READ ${file} existing)
+    string(FIND ${existing} ${line_ending} last_newline REVERSE)
+    string(LENGTH ${existing} length)
+    math(EXPR length "${length}-1")
+    if(NOT length EQUAL last_newline) # file doesn't end with a newline
+        file(APPEND "${file}" "${line_ending}")
+    endif()
+    file(APPEND "${file}" "${line}${line_ending}")
+endfunction()
+
+# Add one or more linker scripts to the target, including a link-time dependency
+#
+# Automatically adds a -L search path for the containing directory (if found),
+# and then adds -T with the filename only. This allows INCLUDE directives to be
+# used to include other linker scripts in the same directory.
+function(target_linker_script target)
+    foreach(scriptfile ${ARGN})
+        get_filename_component(abs_script "${scriptfile}" ABSOLUTE)
+        message(STATUS "Adding linker script ${abs_script}")
+
+        get_filename_component(search_dir "${abs_script}" DIRECTORY)
+        get_filename_component(scriptname "${abs_script}" NAME)
+
+        get_target_property(link_libraries "${target}" LINK_LIBRARIES)
+        list(FIND "${link_libraries}" "-L ${search_dir}" found_search_dir)
+        if(found_search_dir EQUAL "-1")  # not already added as a search path
+            target_link_libraries("${target}" "-L ${search_dir}")
+        endif()
+
+        target_link_libraries("${target}" "-T ${scriptname}")
+
+        # Note: In ESP-IDF, most targets are libraries and libary LINK_DEPENDS don't propagate to
+        # executable(s) the library is linked to. This is done manually in components.cmake.
+        set_property(TARGET "${target}" APPEND PROPERTY LINK_DEPENDS "${abs_script}")
+    endforeach()
+endfunction()
+
+# Convert a CMake list to a JSON list and store it in a variable
+function(make_json_list list variable)
+    string(REPLACE ";" "\", \"" result "[ \"${list}\" ]")
+    set("${variable}" "${result}" PARENT_SCOPE)
+endfunction()

From e7ded7275e83afb4a2ab4fddf764fa4680cc80c4 Mon Sep 17 00:00:00 2001
From: Dong Heng <dongheng@espressif.com>
Date: Thu, 3 May 2018 16:27:04 +0800
Subject: [PATCH 4/5] chore(idf.py): Add "idf.py" tools

---
 tools/idf.py | 389 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 389 insertions(+)
 create mode 100755 tools/idf.py

diff --git a/tools/idf.py b/tools/idf.py
new file mode 100755
index 00000000..247fd3b9
--- /dev/null
+++ b/tools/idf.py
@@ -0,0 +1,389 @@
+#!/usr/bin/env python
+#
+# 'idf.py' is a top-level config/build command line tool for ESP-IDF
+#
+# You don't have to use idf.py, you can use cmake directly
+# (or use cmake in an IDE)
+#
+#
+#
+# Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import sys
+import argparse
+import os
+import os.path
+import subprocess
+import multiprocessing
+import re
+import shutil
+import json
+
+class FatalError(RuntimeError):
+    """
+    Wrapper class for runtime errors that aren't caused by bugs in idf.py or the build proces.s
+    """
+    pass
+
+# Use this Python interpreter for any subprocesses we launch
+PYTHON=sys.executable
+
+# note: os.environ changes don't automatically propagate to child processes,
+# you have to pass this in explicitly
+os.environ["PYTHON"]=sys.executable
+
+# Make flavors, across the various kinds of Windows environments & POSIX...
+if "MSYSTEM" in os.environ:  # MSYS
+    MAKE_CMD = "make"
+    MAKE_GENERATOR = "MSYS Makefiles"
+elif os.name == 'nt':  # other Windows
+    MAKE_CMD = "mingw32-make"
+    MAKE_GENERATOR = "MinGW Makefiles"
+else:
+    MAKE_CMD = "make"
+    MAKE_GENERATOR = "Unix Makefiles"
+
+GENERATORS = [
+    # ('generator name', 'build command line', 'version command line', 'verbose flag')
+    ("Ninja", [ "ninja" ], [ "ninja", "--version" ], "-v"),
+    (MAKE_GENERATOR, [ MAKE_CMD, "-j", str(multiprocessing.cpu_count()+2) ], [ "make", "--version" ], "VERBOSE=1"),
+    ]
+GENERATOR_CMDS = dict( (a[0], a[1]) for a in GENERATORS )
+GENERATOR_VERBOSE = dict( (a[0], a[3]) for a in GENERATORS )
+
+def _run_tool(tool_name, args, cwd):
+    def quote_arg(arg):
+        " Quote 'arg' if necessary "
+        if " " in arg and not (arg.startswith('"') or arg.startswith("'")):
+            return "'" + arg + "'"
+        return arg
+    display_args = " ".join(quote_arg(arg) for arg in args)
+    print("Running %s in directory %s" % (tool_name, quote_arg(cwd)))
+    print('Executing "%s"...' % display_args)
+    try:
+        # Note: we explicitly pass in os.environ here, as we may have set IDF_PATH there during startup
+        subprocess.check_call(args, env=os.environ, cwd=cwd)
+    except subprocess.CalledProcessError as e:
+        raise FatalError("%s failed with exit code %d" % (tool_name, e.returncode))
+
+
+def check_environment():
+    """
+    Verify the environment contains the top-level tools we need to operate
+
+    (cmake will check a lot of other things)
+    """
+    if not executable_exists(["cmake", "--version"]):
+        raise FatalError("'cmake' must be available on the PATH to use idf.py")
+    # find the directory idf.py is in, then the parent directory of this, and assume this is IDF_PATH
+    detected_idf_path = os.path.realpath(os.path.join(os.path.dirname(__file__), ".."))
+    if "IDF_PATH" in os.environ:
+        set_idf_path = os.path.realpath(os.environ["IDF_PATH"])
+        if set_idf_path != detected_idf_path:
+            print("WARNING: IDF_PATH environment variable is set to %s but idf.py path indicates IDF directory %s. Using the environment variable directory, but results may be unexpected..."
+                  % (set_idf_path, detected_idf_path))
+    else:
+        os.environ["IDF_PATH"] = detected_idf_path
+
+def executable_exists(args):
+    try:
+        subprocess.check_output(args)
+        return True
+    except:
+        return False
+
+def detect_cmake_generator():
+    """
+    Find the default cmake generator, if none was specified. Raises an exception if no valid generator is found.
+    """
+    for (generator, _, version_check, _) in GENERATORS:
+        if executable_exists(version_check):
+            return generator
+    raise FatalError("To use idf.py, either the 'ninja' or 'GNU make' build tool must be available in the PATH")
+
+def _ensure_build_directory(args, always_run_cmake=False):
+    """Check the build directory exists and that cmake has been run there.
+
+    If this isn't the case, create the build directory (if necessary) and
+    do an initial cmake run to configure it.
+
+    This function will also check args.generator parameter. If the parameter is incompatible with
+    the build directory, an error is raised. If the parameter is None, this function will set it to
+    an auto-detected default generator or to the value already configured in the build directory.
+    """
+    project_dir = args.project_dir
+    # Verify the project directory
+    if not os.path.isdir(project_dir):
+        if not os.path.exists(project_dir):
+            raise FatalError("Project directory %s does not exist")
+        else:
+            raise FatalError("%s must be a project directory")
+    if not os.path.exists(os.path.join(project_dir, "CMakeLists.txt")):
+        raise FatalError("CMakeLists.txt not found in project directory %s" % project_dir)
+
+    # Verify/create the build directory
+    build_dir = args.build_dir
+    if not os.path.isdir(build_dir):
+        os.mkdir(build_dir)
+    cache_path = os.path.join(build_dir, "CMakeCache.txt")
+    if not os.path.exists(cache_path) or always_run_cmake:
+        if args.generator is None:
+            args.generator = detect_cmake_generator()
+        try:
+            cmake_args = ["cmake", "-G", args.generator]
+            if not args.no_warnings:
+                cmake_args += [ "--warn-uninitialized" ]
+            if args.no_ccache:
+                cmake_args += [ "-DCCACHE_DISABLE=1" ]
+            cmake_args += [ project_dir]
+            _run_tool("cmake", cmake_args, cwd=args.build_dir)
+        except:
+            # don't allow partially valid CMakeCache.txt files,
+            # to keep the "should I run cmake?" logic simple
+            if os.path.exists(cache_path):
+                os.remove(cache_path)
+            raise
+
+    # Learn some things from the CMakeCache.txt file in the build directory
+    cache = parse_cmakecache(cache_path)
+    try:
+        generator = cache["CMAKE_GENERATOR"]
+    except KeyError:
+        generator = detect_cmake_generator()
+    if args.generator is None:
+        args.generator = generator  # reuse the previously configured generator, if none was given
+    if generator != args.generator:
+        raise FatalError("Build is configured for generator '%s' not '%s'. Run 'idf.py fullclean' to start again."
+                           % (generator, args.generator))
+
+    try:
+        home_dir = cache["CMAKE_HOME_DIRECTORY"]
+        if os.path.normcase(os.path.realpath(home_dir)) != os.path.normcase(os.path.realpath(project_dir)):
+            raise FatalError("Build directory '%s' configured for project '%s' not '%s'. Run 'idf.py fullclean' to start again."
+                            % (build_dir, os.path.realpath(home_dir), os.path.realpath(project_dir)))
+    except KeyError:
+        pass  # if cmake failed part way, CMAKE_HOME_DIRECTORY may not be set yet
+
+
+def parse_cmakecache(path):
+    """
+    Parse the CMakeCache file at 'path'.
+
+    Returns a dict of name:value.
+
+    CMakeCache entries also each have a "type", but this is currently ignored.
+    """
+    result = {}
+    with open(path) as f:
+        for line in f:
+            # cmake cache lines look like: CMAKE_CXX_FLAGS_DEBUG:STRING=-g
+            # groups are name, type, value
+            m = re.match(r"^([^#/:=]+):([^:=]+)=(.+)\n$", line)
+            if m:
+               result[m.group(1)] = m.group(3)
+    return result
+
+def build_target(target_name, args):
+    """
+    Execute the target build system to build target 'target_name'
+
+    Calls _ensure_build_directory() which will run cmake to generate a build
+    directory (with the specified generator) as needed.
+    """
+    _ensure_build_directory(args)
+    generator_cmd = GENERATOR_CMDS[args.generator]
+    if not args.no_ccache:
+        # Setting CCACHE_BASEDIR & CCACHE_NO_HASHDIR ensures that project paths aren't stored in the ccache entries
+        # (this means ccache hits can be shared between different projects. It may mean that some debug information
+        # will point to files in another project, if these files are perfect duplicates of each other.)
+        #
+        # It would be nicer to set these from cmake, but there's no cross-platform way to set build-time environment
+        #os.environ["CCACHE_BASEDIR"] = args.build_dir
+        #os.environ["CCACHE_NO_HASHDIR"] = "1"
+        pass
+    if args.verbose:
+        generator_cmd += [ GENERATOR_VERBOSE[args.generator] ]
+
+    _run_tool(generator_cmd[0], generator_cmd + [target_name], args.build_dir)
+
+
+def _get_esptool_args(args):
+    esptool_path = os.path.join(os.environ["IDF_PATH"], "components/esptool_py/esptool/esptool.py")
+    result = [ PYTHON, esptool_path ]
+    if args.port is not None:
+        result += [ "-p", args.port ]
+    result += [ "-b", str(args.baud) ]
+    return result
+
+def flash(action, args):
+    """
+    Run esptool to flash the entire project, from an argfile generated by the build system
+    """
+    flasher_args_path = {  # action -> name of flasher args file generated by build system
+        "bootloader-flash":      "flash_bootloader_args",
+        "partition_table-flash": "flash_partition_table_args",
+        "app-flash":             "flash_app_args",
+        "flash":                 "flash_project_args",
+    }[action]
+    esptool_args = _get_esptool_args(args)
+    esptool_args += [ "write_flash", "@"+flasher_args_path ]
+    _run_tool("esptool.py", esptool_args, args.build_dir)
+
+
+def erase_flash(action, args):
+    esptool_args = _get_esptool_args(args)
+    esptool_args += [ "erase_flash" ]
+    _run_tool("esptool.py", esptool_args, args.build_dir)
+
+
+def monitor(action, args):
+    """
+    Run idf_monitor.py to watch build output
+    """
+    desc_path = os.path.join(args.build_dir, "project_description.json")
+    if not os.path.exists(desc_path):
+        _ensure_build_directory(args)
+    with open(desc_path, "r") as f:
+        project_desc = json.load(f)
+
+    elf_file = os.path.join(args.build_dir, project_desc["app_elf"])
+    if not os.path.exists(elf_file):
+        raise FatalError("ELF file '%s' not found. You need to build & flash the project before running 'monitor', and the binary on the device must match the one in the build directory exactly. Try 'idf.py flash monitor'." % elf_file)
+    idf_monitor = os.path.join(os.environ["IDF_PATH"], "tools/idf_monitor.py")
+    monitor_args = [PYTHON, idf_monitor ]
+    if args.port is not None:
+        monitor_args += [ "-p", args.port ]
+    monitor_args += [ "-b", project_desc["monitor_baud"] ]
+    monitor_args += [ elf_file ]
+    if "MSYSTEM" is os.environ:
+        monitor_args = [ "winpty" ] + monitor_args
+    _run_tool("idf_monitor", monitor_args, args.build_dir)
+
+
+def clean(action, args):
+    if not os.path.isdir(args.build_dir):
+        print("Build directory '%s' not found. Nothing to clean." % args.build_dir)
+        return
+    build_target("clean", args)
+
+def reconfigure(action, args):
+    _ensure_build_directory(args, True)
+
+def fullclean(action, args):
+    build_dir = args.build_dir
+    if not os.path.isdir(build_dir):
+        print("Build directory '%s' not found. Nothing to clean." % build_dir)
+        return
+    if len(os.listdir(build_dir)) == 0:
+        print("Build directory '%s' is empty. Nothing to clean." % build_dir)
+        return
+
+    if not os.path.exists(os.path.join(build_dir, "CMakeCache.txt")):
+        raise FatalError("Directory '%s' doesn't seem to be a CMake build directory. Refusing to automatically delete files in this directory. Delete the directory manually to 'clean' it." % build_dir)
+    red_flags = [ "CMakeLists.txt", ".git", ".svn" ]
+    for red in red_flags:
+        red = os.path.join(build_dir, red)
+        if os.path.exists(red):
+            raise FatalError("Refusing to automatically delete files in directory containing '%s'. Delete files manually if you're sure." % red)
+    # OK, delete everything in the build directory...
+    for f in os.listdir(build_dir):  # TODO: once we are Python 3 only, this can be os.scandir()
+        f = os.path.join(build_dir, f)
+        if os.path.isdir(f):
+            shutil.rmtree(f)
+        else:
+            os.remove(f)
+
+ACTIONS = {
+    # action name : ( function (or alias), dependencies, order-only dependencies )
+    "all" :                  ( build_target, [], [ "reconfigure", "menuconfig", "clean", "fullclean" ] ),
+    "build":                 ( "all",        [], [] ),  # build is same as 'all' target
+    "clean":                 ( clean,        [], [ "fullclean" ] ),
+    "fullclean":             ( fullclean,    [], [] ),
+    "reconfigure":           ( reconfigure,  [], [] ),
+    "menuconfig":            ( build_target, [], [] ),
+    "size":                  ( build_target, [], [ "app" ] ),
+    "size-components":       ( build_target, [], [ "app" ] ),
+    "size-files":            ( build_target, [], [ "app" ] ),
+    "bootloader":            ( build_target, [], [] ),
+    "bootloader-clean":      ( build_target, [], [] ),
+    "bootloader-flash":      ( flash,        [ "bootloader" ], [] ),
+    "app":                   ( build_target, [], [ "clean", "fullclean", "reconfigure" ] ),
+    "app-flash":             ( flash,        [], [ "app" ]),
+    "partition_table":       ( build_target, [], [ "reconfigure" ] ),
+    "partition_table-flash": ( flash,        [ "partition_table" ], []),
+    "flash":                 ( flash,        [ "all" ], [ ] ),
+    "erase_flash":           ( erase_flash,  [], []),
+    "monitor":               ( monitor,      [], [ "flash", "partition_table-flash", "bootloader-flash", "app-flash" ]),
+}
+
+
+def main():
+    parser = argparse.ArgumentParser(description='ESP-IDF build management tool')
+    parser.add_argument('-p', '--port', help="Serial port", default=None)
+    parser.add_argument('-b', '--baud', help="Baud rate", default=460800)
+    parser.add_argument('-C', '--project-dir', help="Project directory", default=os.getcwd())
+    parser.add_argument('-B', '--build-dir', help="Build directory", default=None)
+    parser.add_argument('-G', '--generator', help="Cmake generator", choices=GENERATOR_CMDS.keys())
+    parser.add_argument('-n', '--no-warnings', help="Disable Cmake warnings", action="store_true")
+    parser.add_argument('-v', '--verbose', help="Verbose build output", action="store_true")
+    parser.add_argument('--no-ccache', help="Disable ccache. Otherwise, if ccache is available on the PATH then it will be used for faster builds.", action="store_true")
+    parser.add_argument('actions', help="Actions (build targets or other operations)", nargs='+',
+                        choices=ACTIONS.keys())
+
+    args = parser.parse_args()
+
+    check_environment()
+
+    # Advanced parameter checks
+    if args.build_dir is not None and os.path.realpath(args.project_dir) == os.path.realpath(args.build_dir):
+        raise FatalError("Setting the build directory to the project directory is not supported. Suggest dropping --build-dir option, the default is a 'build' subdirectory inside the project directory.")
+    if args.build_dir is None:
+        args.build_dir = os.path.join(args.project_dir, "build")
+    args.build_dir = os.path.realpath(args.build_dir)
+
+    completed_actions = set()
+    def execute_action(action, remaining_actions):
+        ( function, dependencies, order_dependencies ) = ACTIONS[action]
+        # very simple dependency management, build a set of completed actions and make sure
+        # all dependencies are in it
+        for dep in dependencies:
+            if not dep in completed_actions:
+                execute_action(dep, remaining_actions)
+        for dep in order_dependencies:
+            if dep in remaining_actions and not dep in completed_actions:
+                execute_action(dep, remaining_actions)
+
+        if action in completed_actions:
+            pass  # we've already done this, don't do it twice...
+        elif function in ACTIONS:  # alias of another action
+            execute_action(function, remaining_actions)
+        else:
+            function(action, args)
+
+        completed_actions.add(action)
+
+    while len(args.actions) > 0:
+        execute_action(args.actions[0], args.actions[1:])
+        args.actions.pop(0)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except FatalError as e:
+        print(e)
+        sys.exit(2)
+
+

From 4d52a66cbcf4e548d478ca5fc759639f434eaa1a Mon Sep 17 00:00:00 2001
From: Dong Heng <dongheng@espressif.com>
Date: Thu, 3 May 2018 16:55:23 +0800
Subject: [PATCH 5/5] docs(tools): Update README of tools

---
 tools/README | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/tools/README b/tools/README
index 3a0818cd..fffe7191 100644
--- a/tools/README
+++ b/tools/README
@@ -1,6 +1,11 @@
 README
 
-The SDK uses 'kconfig', 'idf_monitor.py' of esp-idf and information of esp-idf is following:
+Information of 'idf_monitor.py' is following:
 
 URL: https://github.com/espressif/esp-idf
 tag: v3.1-dev
+
+Information of 'cmake', 'kconfig', 'kconfig_new' and 'idf.py' is following:
+
+commit: 48c3ad37
+