scripts/lib/bsp: delete, all users have been removed

With the removal of yocto-bsp and yocto-kernel there are no longer any users
of this library, therefore delete it.

(From meta-yocto rev: 0d44e59bfaa95162cf2133df1d08f6419314bb8e)

Signed-off-by: Joshua Lock <joshua.g.lock@intel.com>
Signed-off-by: Ross Burton <ross.burton@intel.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

1 files changed, 0 insertions, 1931 deletions

diff --git a/scripts/lib/bsp/engine.py b/scripts/lib/bsp/engine.py
deleted file mode 100644
index 07a15bb90c..0000000000
--- a/scripts/lib/bsp/engine.py
+++ /dev/null
@@ -1,1931 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (c) 2012, Intel Corporation.
-# All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-# DESCRIPTION
-# This module implements the templating engine used by 'yocto-bsp' to
-# create BSPs.  The BSP templates are simply the set of files expected
-# to appear in a generated BSP, marked up with a small set of tags
-# used to customize the output.  The engine parses through the
-# templates and generates a Python program containing all the logic
-# and input elements needed to display and retrieve BSP-specific
-# information from the user.  The resulting program uses those results
-# to generate the final BSP files.
-#
-# AUTHORS
-# Tom Zanussi <tom.zanussi (at] intel.com>
-#
-
-import os
-import sys
-from abc import ABCMeta, abstractmethod
-from .tags import *
-import shlex
-import json
-import subprocess
-import shutil
-
-class Line(metaclass=ABCMeta):
-    """
-    Generic (abstract) container representing a line that will appear
-    in the BSP-generating program.
-    """
-
-    def __init__(self, line):
-        self.line = line
-        self.generated_line = ""
-        self.prio = sys.maxsize
-        self.discard = False
-
-    @abstractmethod
-    def gen(self, context = None):
-        """
-        Generate the final executable line that will appear in the
-        BSP-generation program.
-        """
-        pass
-
-    def escape(self, line):
-        """
-        Escape single and double quotes and backslashes until I find
-        something better (re.escape() escapes way too much).
-        """
-        return line.replace("\\", "\\\\").replace("\"", "\\\"").replace("'", "\\'")
-
-    def parse_error(self, msg, lineno, line):
-         raise SyntaxError("%s: %s" % (msg, line))
-
-
-class NormalLine(Line):
-    """
-    Container for normal (non-tag) lines.
-    """
-    def __init__(self, line):
-        Line.__init__(self, line)
-        self.is_filename = False
-        self.is_dirname = False
-        self.out_filebase = None
-
-    def gen(self, context = None):
-        if self.is_filename:
-            line = "current_file = \"" + os.path.join(self.out_filebase, self.escape(self.line)) + "\"; of = open(current_file, \"w\")"
-        elif self.is_dirname:
-            dirname = os.path.join(self.out_filebase, self.escape(self.line))
-            line = "if not os.path.exists(\"" + dirname + "\"): os.mkdir(\"" + dirname + "\")"
-        else:
-            line = "of.write(\"" + self.escape(self.line) + "\\n\")"
-        return line
-
-
-class CodeLine(Line):
-    """
-    Container for Python code tag lines.
-    """
-    def __init__(self, line):
-        Line.__init__(self, line)
-
-    def gen(self, context = None):
-        return self.line
-
-
-class Assignment:
-    """
-    Representation of everything we know about {{=name }} tags.
-    Instances of these are used by Assignment lines.
-    """
-    def __init__(self, start, end, name):
-        self.start = start
-        self.end = end
-        self.name = name
-
-
-class AssignmentLine(NormalLine):
-    """
-    Container for normal lines containing assignment tags.  Assignment
-    tags must be in ascending order of 'start' value.
-    """
-    def __init__(self, line):
-        NormalLine.__init__(self, line)
-        self.assignments = []
-
-    def add_assignment(self, start, end, name):
-        self.assignments.append(Assignment(start, end, name))
-
-    def gen(self, context = None):
-        line = self.escape(self.line)
-
-        for assignment in self.assignments:
-            replacement = "\" + " + assignment.name + " + \""
-            idx = line.find(ASSIGN_TAG)
-            line = line[:idx] + replacement + line[idx + assignment.end - assignment.start:]
-        if self.is_filename:
-            return "current_file = \"" + os.path.join(self.out_filebase, line) + "\"; of = open(current_file, \"w\")"
-        elif self.is_dirname:
-            dirname = os.path.join(self.out_filebase, line)
-            return "if not os.path.exists(\"" + dirname + "\"): os.mkdir(\"" + dirname + "\")"
-        else:
-            return "of.write(\"" + line + "\\n\")"
-
-
-class InputLine(Line):
-    """
-    Base class for Input lines.
-    """
-    def __init__(self, props, tag, lineno):
-        Line.__init__(self, tag)
-        self.props = props
-        self.lineno = lineno
-
-        try:
-            self.prio = int(props["prio"])
-        except KeyError:
-            self.prio = sys.maxsize
-
-    def gen(self, context = None):
-        try:
-            depends_on = self.props["depends-on"]
-            try:
-                depends_on_val = self.props["depends-on-val"]
-            except KeyError:
-                self.parse_error("No 'depends-on-val' for 'depends-on' property",
-                                 self.lineno, self.line)
-        except KeyError:
-            pass
-
-
-class EditBoxInputLine(InputLine):
-    """
-    Base class for 'editbox' Input lines.
-
-    props:
-        name: example - "Load address"
-        msg: example - "Please enter the load address"
-    result:
-        Sets the value of the variable specified by 'name' to
-        whatever the user typed.
-    """
-    def __init__(self, props, tag, lineno):
-        InputLine.__init__(self, props, tag, lineno)
-
-    def gen(self, context = None):
-        InputLine.gen(self, context)
-        name = self.props["name"]
-        if not name:
-            self.parse_error("No input 'name' property found",
-                             self.lineno, self.line)
-        msg = self.props["msg"]
-        if not msg:
-            self.parse_error("No input 'msg' property found",
-                             self.lineno, self.line)
-
-        try:
-            default_choice = self.props["default"]
-        except KeyError:
-            default_choice = ""
-
-        msg += " [default: " + default_choice + "]"
-
-        line = name + " = default(input(\"" + msg + " \"), " + name + ")"
-
-        return line
-
-
-class GitRepoEditBoxInputLine(EditBoxInputLine):
-    """
-    Base class for 'editbox' Input lines for user input of remote git
-    repos.  This class verifies the existence and connectivity of the
-    specified git repo.
-
-    props:
-        name: example - "Load address"
-        msg: example - "Please enter the load address"
-    result:
-        Sets the value of the variable specified by 'name' to
-        whatever the user typed.
-    """
-    def __init__(self, props, tag, lineno):
-        EditBoxInputLine.__init__(self, props, tag, lineno)
-
-    def gen(self, context = None):
-        EditBoxInputLine.gen(self, context)
-        name = self.props["name"]
-        if not name:
-            self.parse_error("No input 'name' property found",
-                             self.lineno, self.line)
-        msg = self.props["msg"]
-        if not msg:
-            self.parse_error("No input 'msg' property found",
-                             self.lineno, self.line)
-
-        try:
-            default_choice = self.props["default"]
-        except KeyError:
-            default_choice = ""
-
-        msg += " [default: " + default_choice + "]"
-
-        line = name + " = get_verified_git_repo(\"" + msg + "\"," + name + ")"
-
-        return line
-
-
-class FileEditBoxInputLine(EditBoxInputLine):
-    """
-    Base class for 'editbox' Input lines for user input of existing
-    files.  This class verifies the existence of the specified file.
-
-    props:
-        name: example - "Load address"
-        msg: example - "Please enter the load address"
-    result:
-        Sets the value of the variable specified by 'name' to
-        whatever the user typed.
-    """
-    def __init__(self, props, tag, lineno):
-        EditBoxInputLine.__init__(self, props, tag, lineno)
-
-    def gen(self, context = None):
-        EditBoxInputLine.gen(self, context)
-        name = self.props["name"]
-        if not name:
-            self.parse_error("No input 'name' property found",
-                             self.lineno, self.line)
-        msg = self.props["msg"]
-        if not msg:
-            self.parse_error("No input 'msg' property found",
-                             self.lineno, self.line)
-
-        try:
-            default_choice = self.props["default"]
-        except KeyError:
-            default_choice = ""
-
-        msg += " [default: " + default_choice + "]"
-
-        line = name + " = get_verified_file(\"" + msg + "\"," + name + ", True)"
-
-        return line
-
-
-class BooleanInputLine(InputLine):
-    """
-    Base class for boolean Input lines.
-    props:
-        name: example - "keyboard"
-        msg:  example - "Got keyboard?"
-    result:
-        Sets the value of the variable specified by 'name' to "yes" or "no"
-        example - keyboard = "yes"
-    """
-    def __init__(self, props, tag, lineno):
-        InputLine.__init__(self, props, tag, lineno)
-
-    def gen(self, context = None):
-        InputLine.gen(self, context)
-        name = self.props["name"]
-        if not name:
-            self.parse_error("No input 'name' property found",
-                             self.lineno, self.line)
-        msg = self.props["msg"]
-        if not msg:
-            self.parse_error("No input 'msg' property found",
-                             self.lineno, self.line)
-
-        try:
-            default_choice = self.props["default"]
-        except KeyError:
-            default_choice = ""
-
-        msg += " [default: " + default_choice + "]"
-
-        line = name + " = boolean(input(\"" + msg + " \"), " + name + ")"
-
-        return line
-
-
-class ListInputLine(InputLine, metaclass=ABCMeta):
-    """
-    Base class for List-based Input lines. e.g. Choicelist, Checklist.
-    """
-
-    def __init__(self, props, tag, lineno):
-        InputLine.__init__(self, props, tag, lineno)
-        self.choices = []
-
-    def gen_choicepair_list(self):
-        """Generate a list of 2-item val:desc lists from self.choices."""
-        if not self.choices:
-            return None
-
-        choicepair_list = list()
-
-        for choice in self.choices:
-            choicepair = []
-            choicepair.append(choice.val)
-            choicepair.append(choice.desc)
-            choicepair_list.append(choicepair)
-
-        return choicepair_list
-
-    def gen_degenerate_choicepair_list(self, choices):
-        """Generate a list of 2-item val:desc with val=desc from passed-in choices."""
-        choicepair_list = list()
-
-        for choice in choices:
-            choicepair = []
-            choicepair.append(choice)
-            choicepair.append(choice)
-            choicepair_list.append(choicepair)
-
-        return choicepair_list
-
-    def exec_listgen_fn(self, context = None):
-        """
-        Execute the list-generating function contained as a string in
-        the "gen" property.
-        """
-        retval = None
-        try:
-            fname = self.props["gen"]
-            modsplit = fname.split('.')
-            mod_fn = modsplit.pop()
-            mod = '.'.join(modsplit)
-
-            __import__(mod)
-            # python 2.7 has a better way to do this using importlib.import_module
-            m = sys.modules[mod]
-
-            fn = getattr(m, mod_fn)
-            if not fn:
-                self.parse_error("couldn't load function specified for 'gen' property ",
-                                 self.lineno, self.line)
-            retval = fn(context)
-            if not retval:
-                self.parse_error("function specified for 'gen' property returned nothing ",
-                                 self.lineno, self.line)
-        except KeyError:
-            pass
-
-        return retval
-
-    def gen_choices_str(self, choicepairs):
-        """
-        Generate a numbered list of choices from a list of choicepairs
-        for display to the user.
-        """
-        choices_str = ""
-
-        for i, choicepair in enumerate(choicepairs):
-            choices_str += "\t" + str(i + 1) + ") " + choicepair[1] + "\n"
-
-        return choices_str
-
-    def gen_choices_val_str(self, choicepairs):
-        """
-        Generate an array of choice values corresponding to the
-        numbered list generated by gen_choices_str().
-        """
-        choices_val_list = "["
-
-        for i, choicepair in enumerate(choicepairs):
-            choices_val_list += "\"" + choicepair[0] + "\","
-        choices_val_list += "]"
-
-        return choices_val_list
-
-    def gen_choices_val_list(self, choicepairs):
-        """
-        Generate an array of choice values corresponding to the
-        numbered list generated by gen_choices_str().
-        """
-        choices_val_list = []
-
-        for i, choicepair in enumerate(choicepairs):
-            choices_val_list.append(choicepair[0])
-
-        return choices_val_list
-
-    def gen_choices_list(self, context = None, checklist = False):
-        """
-        Generate an array of choice values corresponding to the
-        numbered list generated by gen_choices_str().
-        """
-        choices = self.exec_listgen_fn(context)
-        if choices:
-            if len(choices) == 0:
-                self.parse_error("No entries available for input list",
-                                 self.lineno, self.line)
-            choicepairs = self.gen_degenerate_choicepair_list(choices)
-        else:
-            if len(self.choices) == 0:
-                self.parse_error("No entries available for input list",
-                                 self.lineno, self.line)
-            choicepairs = self.gen_choicepair_list()
-
-        return choicepairs
-
-    def gen_choices(self, context = None, checklist = False):
-        """
-        Generate an array of choice values corresponding to the
-        numbered list generated by gen_choices_str(), display it to
-        the user, and process the result.
-        """
-        msg = self.props["msg"]
-        if not msg:
-            self.parse_error("No input 'msg' property found",
-                             self.lineno, self.line)
-
-        try:
-            default_choice = self.props["default"]
-        except KeyError:
-            default_choice = ""
-
-        msg += " [default: " + default_choice + "]"
-
-        choicepairs = self.gen_choices_list(context, checklist)
-
-        choices_str = self.gen_choices_str(choicepairs)
-        choices_val_list = self.gen_choices_val_list(choicepairs)
-        if checklist:
-            choiceval = default(find_choicevals(input(msg + "\n" + choices_str), choices_val_list), default_choice)
-        else:
-            choiceval = default(find_choiceval(input(msg + "\n" + choices_str), choices_val_list), default_choice)
-
-        return choiceval
-
-
-def find_choiceval(choice_str, choice_list):
-    """
-    Take number as string and return val string from choice_list,
-    empty string if oob.  choice_list is a simple python list.
-    """
-    choice_val = ""
-
-    try:
-        choice_idx = int(choice_str)
-        if choice_idx <= len(choice_list):
-            choice_idx -= 1
-            choice_val = choice_list[choice_idx]
-    except ValueError:
-        pass
-
-    return choice_val
-
-
-def find_choicevals(choice_str, choice_list):
-    """
-    Take numbers as space-separated string and return vals list from
-    choice_list, empty list if oob.  choice_list is a simple python
-    list.
-    """
-    choice_vals = []
-
-    choices = choice_str.split()
-    for choice in choices:
-        choice_vals.append(find_choiceval(choice, choice_list))
-
-    return choice_vals
-
-
-def default(input_str, name):
-    """
-    Return default if no input_str, otherwise stripped input_str.
-    """
-    if not input_str:
-        return name
-
-    return input_str.strip()
-
-
-def verify_git_repo(giturl):
-    """
-    Verify that the giturl passed in can be connected to.  This can be
-    used as a check for the existence of the given repo and/or basic
-    git remote connectivity.
-
-    Returns True if the connection was successful, fals otherwise
-    """
-    if not giturl:
-        return False
-
-    gitcmd = "git ls-remote %s > /dev/null 2>&1" % (giturl)
-    rc = subprocess.call(gitcmd, shell=True)
-    if rc == 0:
-        return True
-
-    return False
-
-
-def get_verified_git_repo(input_str, name):
-    """
-    Return git repo if verified, otherwise loop forever asking user
-    for filename.
-    """
-    msg = input_str.strip() + " "
-
-    giturl = default(input(msg), name)
-
-    while True:
-        if verify_git_repo(giturl):
-            return giturl
-        giturl = default(input(msg), name)
-
-
-def get_verified_file(input_str, name, filename_can_be_null):
-    """
-    Return filename if the file exists, otherwise loop forever asking
-    user for filename.
-    """
-    msg = input_str.strip() + " "
-
-    filename = default(input(msg), name)
-
-    while True:
-        if not filename and filename_can_be_null:
-            return filename
-        if os.path.isfile(filename):
-            return filename
-        filename = default(input(msg), name)
-
-
-def replace_file(replace_this, with_this):
-    """
-    Replace the given file with the contents of filename, retaining
-    the original filename.
-    """
-    try:
-        replace_this.close()
-        shutil.copy(with_this, replace_this.name)
-    except IOError:
-        pass
-
-
-def boolean(input_str, name):
-    """
-    Return lowercase version of first char in string, or value in name.
-    """
-    if not input_str:
-        return name
-
-    str = input_str.lower().strip()
-    if str and str[0] == "y" or str[0] == "n":
-        return str[0]
-    else:
-        return name
-
-
-def strip_base(input_str):
-    """
-    strip '/base' off the end of input_str, so we can use 'base' in
-    the branch names we present to the user.
-    """
-    if input_str and input_str.endswith("/base"):
-        return input_str[:-len("/base")]
-    return input_str.strip()
-
-
-deferred_choices = {}
-
-def gen_choices_defer(input_line, context, checklist = False):
-    """
-    Save the context hashed the name of the input item, which will be
-    passed to the gen function later.
-    """
-    name = input_line.props["name"]
-
-    try:
-        nameappend = input_line.props["nameappend"]
-    except KeyError:
-        nameappend = ""
-
-    try:
-        branches_base = input_line.props["branches_base"]
-    except KeyError:
-        branches_base = ""
-
-    filename = input_line.props["filename"]
-
-    closetag_start = filename.find(CLOSE_TAG)
-
-    if closetag_start != -1:
-        filename = filename[closetag_start + len(CLOSE_TAG):]
-
-    filename = filename.strip()
-    filename = os.path.splitext(filename)[0]
-
-    captured_context = capture_context(context)
-    context["filename"] = filename
-    captured_context["filename"] = filename
-    context["nameappend"] = nameappend
-    captured_context["nameappend"] = nameappend
-    context["branches_base"] = branches_base
-    captured_context["branches_base"] = branches_base
-
-    deferred_choice = (input_line, captured_context, checklist)
-    key = name + "_" + filename + "_" + nameappend
-    deferred_choices[key] = deferred_choice
-
-
-def invoke_deferred_choices(name):
-    """
-    Invoke the choice generation function using the context hashed by
-    'name'.
-    """
-    deferred_choice = deferred_choices[name]
-    input_line = deferred_choice[0]
-    context = deferred_choice[1]
-    checklist = deferred_choice[2]
-
-    context["name"] = name
-
-    choices = input_line.gen_choices(context, checklist)
-
-    return choices
-
-
-class ChoicelistInputLine(ListInputLine):
-    """
-    Base class for choicelist Input lines.
-    props:
-        name: example - "xserver_choice"
-        msg:  example - "Please select an xserver for this machine"
-    result:
-        Sets the value of the variable specified by 'name' to whichever Choice was chosen
-        example - xserver_choice = "xserver_vesa"
-    """
-    def __init__(self, props, tag, lineno):
-        ListInputLine.__init__(self, props, tag, lineno)
-
-    def gen(self, context = None):
-        InputLine.gen(self, context)
-
-        gen_choices_defer(self, context)
-        name = self.props["name"]
-        nameappend = context["nameappend"]
-        filename = context["filename"]
-
-        try:
-            default_choice = self.props["default"]
-        except KeyError:
-            default_choice = ""
-
-        line = name + " = default(invoke_deferred_choices(\"" + name + "_" + filename + "_" + nameappend + "\"), \"" + default_choice + "\")"
-
-        return line
-
-
-class ListValInputLine(InputLine):
-    """
-    Abstract base class for choice and checkbox Input lines.
-    """
-    def __init__(self, props, tag, lineno):
-        InputLine.__init__(self, props, tag, lineno)
-
-        try:
-            self.val = self.props["val"]
-        except KeyError:
-            self.parse_error("No input 'val' property found", self.lineno, self.line)
-
-        try:
-            self.desc = self.props["msg"]
-        except KeyError:
-            self.parse_error("No input 'msg' property found", self.lineno, self.line)
-
-
-class ChoiceInputLine(ListValInputLine):
-    """
-    Base class for choicelist item Input lines.
-    """
-    def __init__(self, props, tag, lineno):
-        ListValInputLine.__init__(self, props, tag, lineno)
-
-    def gen(self, context = None):
-        return None
-
-
-class ChecklistInputLine(ListInputLine):
-    """
-    Base class for checklist Input lines.
-    """
-    def __init__(self, props, tag, lineno):
-        ListInputLine.__init__(self, props, tag, lineno)
-
-    def gen(self, context = None):
-        InputLine.gen(self, context)
-
-        gen_choices_defer(self, context, True)
-        name = self.props["name"]
-        nameappend = context["nameappend"]
-        filename = context["filename"]
-
-        try:
-            default_choice = self.props["default"]
-        except KeyError:
-            default_choice = ""
-
-        line = name + " = default(invoke_deferred_choices(\"" + name + "_" + filename + "_" + nameappend + "\"), \"" + default_choice + "\")"
-
-        return line
-
-
-class CheckInputLine(ListValInputLine):
-    """
-    Base class for checklist item Input lines.
-    """
-    def __init__(self, props, tag, lineno):
-        ListValInputLine.__init__(self, props, tag, lineno)
-
-    def gen(self, context = None):
-        return None
-
-
-dirname_substitutions = {}
-
-class SubstrateBase(object):
-    """
-    Base class for both expanded and unexpanded file and dir container
-    objects.
-    """
-    def __init__(self, filename, filebase, out_filebase):
-        self.filename = filename
-        self.filebase = filebase
-        self.translated_filename = filename
-        self.out_filebase = out_filebase
-        self.raw_lines = []
-        self.expanded_lines = []
-        self.prev_choicelist = None
-
-    def parse_error(self, msg, lineno, line):
-         raise SyntaxError("%s: [%s: %d]: %s" % (msg, self.filename, lineno, line))
-
-    def expand_input_tag(self, tag, lineno):
-        """
-        Input tags consist of the word 'input' at the beginning,
-        followed by name:value property pairs which are converted into
-        a dictionary.
-        """
-        propstr = tag[len(INPUT_TAG):]
-
-        props = dict(prop.split(":", 1) for prop in shlex.split(propstr))
-        props["filename"] = self.filename
-
-        input_type = props[INPUT_TYPE_PROPERTY]
-        if not props[INPUT_TYPE_PROPERTY]:
-            self.parse_error("No input 'type' property found", lineno, tag)
-
-        if input_type == "boolean":
-            return BooleanInputLine(props, tag, lineno)
-        if input_type == "edit":
-            return EditBoxInputLine(props, tag, lineno)
-        if input_type == "edit-git-repo":
-            return GitRepoEditBoxInputLine(props, tag, lineno)
-        if input_type == "edit-file":
-            return FileEditBoxInputLine(props, tag, lineno)
-        elif input_type == "choicelist":
-            self.prev_choicelist = ChoicelistInputLine(props, tag, lineno)
-            return self.prev_choicelist
-        elif input_type == "choice":
-            if not self.prev_choicelist:
-                self.parse_error("Found 'choice' input tag but no previous choicelist",
-                                 lineno, tag)
-            choice = ChoiceInputLine(props, tag, lineno)
-            self.prev_choicelist.choices.append(choice)
-            return choice
-        elif input_type == "checklist":
-            return ChecklistInputLine(props, tag, lineno)
-        elif input_type == "check":
-            return CheckInputLine(props, tag, lineno)
-
-    def expand_assignment_tag(self, start, line, lineno):
-        """
-        Expand all tags in a line.
-        """
-        expanded_line = AssignmentLine(line.rstrip())
-
-        while start != -1:
-            end = line.find(CLOSE_TAG, start)
-            if end == -1:
-                self.parse_error("No close tag found for assignment tag", lineno, line)
-            else:
-                name = line[start + len(ASSIGN_TAG):end].strip()
-                expanded_line.add_assignment(start, end + len(CLOSE_TAG), name)
-                start = line.find(ASSIGN_TAG, end)
-
-        return expanded_line
-
-    def expand_tag(self, line, lineno):
-        """
-        Returns a processed tag line, or None if there was no tag
-
-        The rules for tags are very simple:
-            - No nested tags
-            - Tags start with {{ and end with }}
-            - An assign tag, {{=, can appear anywhere and will
-              be replaced with what the assignment evaluates to
-            - Any other tag occupies the whole line it is on
-                - if there's anything else on the tag line, it's an error
-                - if it starts with 'input', it's an input tag and
-                  will only be used for prompting and setting variables
-                - anything else is straight Python
-                - tags are in effect only until the next blank line or tag or 'pass' tag
-                - we don't have indentation in tags, but we need some way to end a block
-                  forcefully without blank lines or other tags - that's the 'pass' tag
-                - todo: implement pass tag
-                - directories and filenames can have tags as well, but only assignment
-                  and 'if' code lines
-                - directories and filenames are the only case where normal tags can
-                  coexist with normal text on the same 'line'
-        """
-        start = line.find(ASSIGN_TAG)
-        if start != -1:
-            return self.expand_assignment_tag(start, line, lineno)
-
-        start = line.find(OPEN_TAG)
-        if start == -1:
-            return None
-
-        end = line.find(CLOSE_TAG, 0)
-        if end == -1:
-             self.parse_error("No close tag found for open tag", lineno, line)
-
-        tag = line[start + len(OPEN_TAG):end].strip()
-
-        if not tag.lstrip().startswith(INPUT_TAG):
-            return CodeLine(tag)
-
-        return self.expand_input_tag(tag, lineno)
-
-    def append_translated_filename(self, filename):
-        """
-        Simply append filename to translated_filename
-        """
-        self.translated_filename = os.path.join(self.translated_filename, filename)
-
-    def get_substituted_file_or_dir_name(self, first_line, tag):
-        """
-        If file or dir names contain name substitutions, return the name
-        to substitute.  Note that this is just the file or dirname and
-        doesn't include the path.
-        """
-        filename = first_line.find(tag)
-        if filename != -1:
-            filename += len(tag)
-        substituted_filename = first_line[filename:].strip()
-        this = substituted_filename.find(" this")
-        if this != -1:
-            head, tail = os.path.split(self.filename)
-            substituted_filename = substituted_filename[:this + 1] + tail
-            if tag == DIRNAME_TAG: # get rid of .noinstall in dirname
-                substituted_filename = substituted_filename.split('.')[0]
-
-        return substituted_filename
-
-    def get_substituted_filename(self, first_line):
-        """
-        If a filename contains a name substitution, return the name to
-        substitute.  Note that this is just the filename and doesn't
-        include the path.
-        """
-        return self.get_substituted_file_or_dir_name(first_line, FILENAME_TAG)
-
-    def get_substituted_dirname(self, first_line):
-        """
-        If a dirname contains a name substitution, return the name to
-        substitute.  Note that this is just the dirname and doesn't
-        include the path.
-        """
-        return self.get_substituted_file_or_dir_name(first_line, DIRNAME_TAG)
-
-    def substitute_filename(self, first_line):
-        """
-        Find the filename in first_line and append it to translated_filename.
-        """
-        substituted_filename = self.get_substituted_filename(first_line)
-        self.append_translated_filename(substituted_filename);
-
-    def substitute_dirname(self, first_line):
-        """
-        Find the dirname in first_line and append it to translated_filename.
-        """
-        substituted_dirname = self.get_substituted_dirname(first_line)
-        self.append_translated_filename(substituted_dirname);
-
-    def is_filename_substitution(self, line):
-        """
-        Do we have a filename subustition?
-        """
-        if line.find(FILENAME_TAG) != -1:
-            return True
-        return False
-
-    def is_dirname_substitution(self, line):
-        """
-        Do we have a dirname subustition?
-        """
-        if line.find(DIRNAME_TAG) != -1:
-            return True
-        return False
-
-    def translate_dirname(self, first_line):
-        """
-        Just save the first_line mapped by filename.  The later pass
-        through the directories will look for a dirname.noinstall
-        match and grab the substitution line.
-        """
-        dirname_substitutions[self.filename] = first_line
-
-    def translate_dirnames_in_path(self, path):
-        """
-        Translate dirnames below this file or dir, not including tail.
-        dirname_substititions is keyed on actual untranslated filenames.
-        translated_path contains the subsititutions for each element.
-        """
-        remainder = path[len(self.filebase)+1:]
-        translated_path = untranslated_path = self.filebase
-
-        untranslated_dirs = remainder.split(os.sep)
-
-        for dir in untranslated_dirs:
-            key = os.path.join(untranslated_path, dir + '.noinstall')
-            try:
-                first_line = dirname_substitutions[key]
-            except KeyError:
-                translated_path = os.path.join(translated_path, dir)
-                untranslated_path = os.path.join(untranslated_path, dir)
-                continue
-            substituted_dir = self.get_substituted_dirname(first_line)
-            translated_path = os.path.join(translated_path, substituted_dir)
-            untranslated_path = os.path.join(untranslated_path, dir)
-
-        return translated_path
-
-    def translate_file_or_dir_name(self):
-        """
-        Originally we were allowed to use open/close/assign tags and python
-        code in the filename, which fit in nicely with the way we
-        processed the templates and generated code.  Now that we can't
-        do that, we make those tags proper file contents and have this
-        pass substitute the nice but non-functional names with those
-        'strange' ones, and then proceed as usual.
-
-        So, if files or matching dir<.noinstall> files contain
-        filename substitutions, this function translates them into the
-        corresponding 'strange' names, which future passes will expand
-        as they always have.  The resulting pathname is kept in the
-        file or directory's translated_filename.  Another way to think
-        about it is that self.filename is the input filename, and
-        translated_filename is the output filename before expansion.
-        """
-        # remove leaf file or dirname
-        head, tail = os.path.split(self.filename)
-        translated_path = self.translate_dirnames_in_path(head)
-        self.translated_filename = translated_path
-
-        # This is a dirname - does it have a matching .noinstall with
-        # a substitution?  If so, apply the dirname subsititution.
-        if not os.path.isfile(self.filename):
-            key = self.filename + ".noinstall"
-            try:
-                first_line = dirname_substitutions[key]
-            except KeyError:
-                self.append_translated_filename(tail)
-                return
-            self.substitute_dirname(first_line)
-            return
-
-        f = open(self.filename)
-        first_line = f.readline()
-        f.close()
-
-        # This is a normal filename not needing translation, just use
-        # it as-is.
-        if not first_line or not first_line.startswith("#"):
-            self.append_translated_filename(tail)
-            return
-
-        # If we have a filename substitution (first line in the file
-        # is a FILENAME_TAG line) do the substitution now.  If we have
-        # a dirname substitution (DIRNAME_TAG in dirname.noinstall
-        # meta-file), hash it so we can apply it when we see the
-        # matching dirname later.  Otherwise we have a regular
-        # filename, just use it as-is.
-        if self.is_filename_substitution(first_line):
-            self.substitute_filename(first_line)
-        elif self.is_dirname_substitution(first_line):
-            self.translate_dirname(first_line)
-        else:
-            self.append_translated_filename(tail)
-
-    def expand_file_or_dir_name(self):
-        """
-        Expand file or dir names into codeline.  Dirnames and
-        filenames can only have assignments or if statements.  First
-        translate if statements into CodeLine + (dirname or filename
-        creation).
-        """
-        lineno = 0
-
-        line = self.translated_filename[len(self.filebase):]
-        if line.startswith("/"):
-            line = line[1:]
-        opentag_start = -1
-
-        start = line.find(OPEN_TAG)
-        while start != -1:
-            if not line[start:].startswith(ASSIGN_TAG):
-                opentag_start = start
-                break
-            start += len(ASSIGN_TAG)
-            start = line.find(OPEN_TAG, start)
-
-        if opentag_start != -1:
-            end = line.find(CLOSE_TAG, opentag_start)
-            if end == -1:
-                self.parse_error("No close tag found for open tag", lineno, line)
-            # we have a {{ tag i.e. code
-            tag = line[opentag_start + len(OPEN_TAG):end].strip()
-            if not tag.lstrip().startswith(IF_TAG):
-                self.parse_error("Only 'if' tags are allowed in file or directory names",
-                                 lineno, line)
-            self.expanded_lines.append(CodeLine(tag))
-
-            # everything after }} is the actual filename (possibly with assignments)
-            # everything before is the pathname
-            line = line[:opentag_start] + line[end + len(CLOSE_TAG):].strip()
-
-        assign_start = line.find(ASSIGN_TAG)
-        if assign_start != -1:
-            assignment_tag = self.expand_assignment_tag(assign_start, line, lineno)
-            if isinstance(self, SubstrateFile):
-                assignment_tag.is_filename = True
-                assignment_tag.out_filebase = self.out_filebase
-            elif isinstance(self, SubstrateDir):
-                assignment_tag.is_dirname = True
-                assignment_tag.out_filebase = self.out_filebase
-            self.expanded_lines.append(assignment_tag)
-            return
-
-        normal_line = NormalLine(line)
-        if isinstance(self, SubstrateFile):
-            normal_line.is_filename = True
-            normal_line.out_filebase = self.out_filebase
-        elif isinstance(self, SubstrateDir):
-            normal_line.is_dirname = True
-            normal_line.out_filebase = self.out_filebase
-        self.expanded_lines.append(normal_line)
-
-    def expand(self):
-        """
-        Expand the file or dir name first, eventually this ends up
-        creating the file or dir.
-        """
-        self.translate_file_or_dir_name()
-        self.expand_file_or_dir_name()
-
-
-class SubstrateFile(SubstrateBase):
-    """
-    Container for both expanded and unexpanded substrate files.
-    """
-    def __init__(self, filename, filebase, out_filebase):
-        SubstrateBase.__init__(self, filename, filebase, out_filebase)
-
-    def read(self):
-        if self.raw_lines:
-            return
-        f = open(self.filename)
-        self.raw_lines = f.readlines()
-
-    def expand(self):
-        """Expand the contents of all template tags in the file."""
-        SubstrateBase.expand(self)
-        self.read()
-
-        for lineno, line in enumerate(self.raw_lines):
-            # only first line can be a filename substitition
-            if lineno == 0 and line.startswith("#") and FILENAME_TAG in line:
-                continue # skip it - we've already expanded it
-            expanded_line = self.expand_tag(line, lineno + 1) # humans not 0-based
-            if not expanded_line:
-                expanded_line = NormalLine(line.rstrip())
-            self.expanded_lines.append(expanded_line)
-
-    def gen(self, context = None):
-        """Generate the code that generates the BSP."""
-        base_indent = 0
-
-        indent = new_indent = base_indent
-
-        for line in self.expanded_lines:
-            genline = line.gen(context)
-            if not genline:
-                continue
-            if isinstance(line, InputLine):
-                line.generated_line = genline
-                continue
-            if genline.startswith(OPEN_START):
-                if indent == 1:
-                    base_indent = 1
-            if indent:
-                if genline == BLANKLINE_STR or (not genline.startswith(NORMAL_START)
-                                                and not genline.startswith(OPEN_START)):
-                    indent = new_indent = base_indent
-            if genline.endswith(":"):
-                new_indent = base_indent + 1
-            line.generated_line = (indent * INDENT_STR) + genline
-            indent = new_indent
-
-
-class SubstrateDir(SubstrateBase):
-    """
-    Container for both expanded and unexpanded substrate dirs.
-    """
-    def __init__(self, filename, filebase, out_filebase):
-        SubstrateBase.__init__(self, filename, filebase, out_filebase)
-
-    def expand(self):
-        SubstrateBase.expand(self)
-
-    def gen(self, context = None):
-        """Generate the code that generates the BSP."""
-        indent = new_indent = 0
-        for line in self.expanded_lines:
-            genline = line.gen(context)
-            if not genline:
-                continue
-            if genline.endswith(":"):
-                new_indent = 1
-            else:
-                new_indent = 0
-            line.generated_line = (indent * INDENT_STR) + genline
-            indent = new_indent
-
-
-def expand_target(target, all_files, out_filebase):
-    """
-    Expand the contents of all template tags in the target.  This
-    means removing tags and categorizing or creating lines so that
-    future passes can process and present input lines and generate the
-    corresponding lines of the Python program that will be exec'ed to
-    actually produce the final BSP.  'all_files' includes directories.
-    """
-    for root, dirs, files in os.walk(target):
-        for file in files:
-            if file.endswith("~") or file.endswith("#"):
-                continue
-            f = os.path.join(root, file)
-            sfile = SubstrateFile(f, target, out_filebase)
-            sfile.expand()
-            all_files.append(sfile)
-
-        for dir in dirs:
-            d = os.path.join(root, dir)
-            sdir = SubstrateDir(d, target, out_filebase)
-            sdir.expand()
-            all_files.append(sdir)
-
-
-def gen_program_machine_lines(machine, program_lines):
-    """
-    Use the input values we got from the command line.
-    """
-    line = "machine = \"" + machine + "\""
-    program_lines.append(line)
-
-    line = "layer_name = \"" + machine + "\""
-    program_lines.append(line)
-
-
-def sort_inputlines(input_lines):
-    """Sort input lines according to priority (position)."""
-    input_lines.sort(key = lambda l: l.prio)
-
-
-def find_parent_dependency(lines, depends_on):
-    for i, line in lines:
-        if isinstance(line, CodeLine):
-            continue
-        if line.props["name"] == depends_on:
-            return i
-
-    return -1
-
-
-def process_inputline_dependencies(input_lines, all_inputlines):
-    """If any input lines depend on others, put the others first."""
-    for line in input_lines:
-        if isinstance(line, InputLineGroup):
-            group_inputlines = []
-            process_inputline_dependencies(line.group, group_inputlines)
-            line.group = group_inputlines
-            all_inputlines.append(line)
-            continue
-
-        if isinstance(line, CodeLine) or isinstance(line, NormalLine):
-            all_inputlines.append(line)
-            continue
-
-        try:
-            depends_on = line.props["depends-on"]
-            depends_codeline = "if " + line.props["depends-on"] + " == \"" + line.props["depends-on-val"] + "\":"
-            all_inputlines.append(CodeLine(depends_codeline))
-            all_inputlines.append(line)
-        except KeyError:
-            all_inputlines.append(line)
-
-
-def conditional_filename(filename):
-    """
-    Check if the filename itself contains a conditional statement.  If
-    so, return a codeline for it.
-    """
-    opentag_start = filename.find(OPEN_TAG)
-
-    if opentag_start != -1:
-        if filename[opentag_start:].startswith(ASSIGN_TAG):
-            return None
-        end = filename.find(CLOSE_TAG, opentag_start)
-        if end == -1:
-            print("No close tag found for open tag in filename %s" % filename)
-            sys.exit(1)
-
-        # we have a {{ tag i.e. code
-        tag = filename[opentag_start + len(OPEN_TAG):end].strip()
-        if not tag.lstrip().startswith(IF_TAG):
-            print("Only 'if' tags are allowed in file or directory names, filename: %s" % filename)
-            sys.exit(1)
-
-        return CodeLine(tag)
-
-    return None
-
-
-class InputLineGroup(InputLine):
-    """
-    InputLine that does nothing but group other input lines
-    corresponding to all the input lines in a SubstrateFile so they
-    can be generated as a group.  prio is the only property used.
-    """
-    def __init__(self, codeline):
-        InputLine.__init__(self, {}, "", 0)
-        self.group = []
-        self.prio = sys.maxsize
-        self.group.append(codeline)
-
-    def append(self, line):
-        self.group.append(line)
-        if line.prio < self.prio:
-            self.prio = line.prio
-
-    def len(self):
-        return len(self.group)
-
-
-def gather_inputlines(files):
-    """
-    Gather all the InputLines - we want to generate them first.
-    """
-    all_inputlines = []
-    input_lines = []
-
-    for file in files:
-        if isinstance(file, SubstrateFile):
-            group = None
-            basename = os.path.basename(file.translated_filename)
-
-            codeline = conditional_filename(basename)
-            if codeline:
-                group = InputLineGroup(codeline)
-
-            have_condition = False
-            condition_to_write = None
-            for line in file.expanded_lines:
-                if isinstance(line, CodeLine):
-                    have_condition = True
-                    condition_to_write = line
-                    continue
-                if isinstance(line, InputLine):
-                    if group:
-                        if condition_to_write:
-                            condition_to_write.prio = line.prio
-                            condition_to_write.discard = True
-                            group.append(condition_to_write)
-                            condition_to_write = None
-                        group.append(line)
-                    else:
-                        if condition_to_write:
-                            condition_to_write.prio = line.prio
-                            condition_to_write.discard = True
-                            input_lines.append(condition_to_write)
-                            condition_to_write = None
-                        input_lines.append(line)
-                else:
-                    if condition_to_write:
-                        condition_to_write = None
-                    if have_condition:
-                        if not line.line.strip():
-                            line.discard = True
-                            input_lines.append(line)
-                    have_condition = False
-
-            if group and group.len() > 1:
-                input_lines.append(group)
-
-    sort_inputlines(input_lines)
-    process_inputline_dependencies(input_lines, all_inputlines)
-
-    return all_inputlines
-
-
-def run_program_lines(linelist, codedump):
-    """
-    For a single file, print all the python code into a buf and execute it.
-    """
-    buf = "\n".join(linelist)
-
-    if codedump:
-        of = open("bspgen.out", "w")
-        of.write(buf)
-        of.close()
-    exec(buf)
-
-
-def gen_target(files, context = None):
-    """
-    Generate the python code for each file.
-    """
-    for file in files:
-        file.gen(context)
-
-
-def gen_program_header_lines(program_lines):
-    """
-    Generate any imports we need.
-    """
-    program_lines.append("current_file = \"\"")
-
-
-def gen_supplied_property_vals(properties, program_lines):
-    """
-    Generate user-specified entries for input values instead of
-    generating input prompts.
-    """
-    for name, val in properties.items():
-        program_line = name + " = \"" + val + "\""
-        program_lines.append(program_line)
-
-
-def gen_initial_property_vals(input_lines, program_lines):
-    """
-    Generate null or default entries for input values, so we don't
-    have undefined variables.
-    """
-    for line in input_lines:
-        if isinstance(line, InputLineGroup):
-            gen_initial_property_vals(line.group, program_lines)
-            continue
-
-        if isinstance(line, InputLine):
-            try:
-                name = line.props["name"]
-                try:
-                    default_val = "\"" + line.props["default"] + "\""
-                except:
-                    default_val = "\"\""
-                program_line = name + " = " + default_val
-                program_lines.append(program_line)
-            except KeyError:
-                pass
-
-
-def gen_program_input_lines(input_lines, program_lines, context, in_group = False):
-    """
-    Generate only the input lines used for prompting the user.  For
-    that, we only have input lines and CodeLines that affect the next
-    input line.
-    """
-    indent = new_indent = 0
-
-    for line in input_lines:
-        if isinstance(line, InputLineGroup):
-            gen_program_input_lines(line.group, program_lines, context, True)
-            continue
-        if not line.line.strip():
-            continue
-
-        genline = line.gen(context)
-        if not genline:
-            continue
-        if genline.endswith(":"):
-            new_indent += 1
-        else:
-            if indent > 1 or (not in_group and indent):
-                new_indent -= 1
-
-        line.generated_line = (indent * INDENT_STR) + genline
-        program_lines.append(line.generated_line)
-
-        indent = new_indent
-
-
-def gen_program_lines(target_files, program_lines):
-    """
-    Generate the program lines that make up the BSP generation
-    program.  This appends the generated lines of all target_files to
-    program_lines, and skips input lines, which are dealt with
-    separately, or omitted.
-    """
-    for file in target_files:
-        if file.filename.endswith("noinstall"):
-            continue
-
-        for line in file.expanded_lines:
-            if isinstance(line, InputLine):
-                continue
-            if line.discard:
-                continue
-
-            program_lines.append(line.generated_line)
-
-
-def create_context(machine, arch, scripts_path):
-    """
-    Create a context object for use in deferred function invocation.
-    """
-    context = {}
-
-    context["machine"] = machine
-    context["arch"] = arch
-    context["scripts_path"] = scripts_path
-
-    return context
-
-
-def capture_context(context):
-    """
-    Create a context object for use in deferred function invocation.
-    """
-    captured_context = {}
-
-    captured_context["machine"] = context["machine"]
-    captured_context["arch"] = context["arch"]
-    captured_context["scripts_path"] = context["scripts_path"]
-
-    return captured_context
-
-
-def expand_targets(context, bsp_output_dir, expand_common=True):
-    """
-    Expand all the tags in both the common and machine-specific
-    'targets'.
-
-    If expand_common is False, don't expand the common target (this
-    option is used to create special-purpose layers).
-    """
-    target_files = []
-
-    machine = context["machine"]
-    arch = context["arch"]
-    scripts_path = context["scripts_path"]
-
-    lib_path = scripts_path + '/lib'
-    bsp_path = lib_path + '/bsp'
-    arch_path = bsp_path + '/substrate/target/arch'
-
-    if expand_common:
-        common = os.path.join(arch_path, "common")
-        expand_target(common, target_files, bsp_output_dir)
-
-    arches = os.listdir(arch_path)
-    if arch not in arches or arch == "common":
-        print("Invalid karch, exiting\n")
-        sys.exit(1)
-
-    target = os.path.join(arch_path, arch)
-    expand_target(target, target_files, bsp_output_dir)
-
-    gen_target(target_files, context)
-
-    return target_files
-
-
-def yocto_common_create(machine, target, scripts_path, layer_output_dir, codedump, properties_file, properties_str="", expand_common=True):
-    """
-    Common layer-creation code
-
-    machine - user-defined machine name (if needed, will generate 'machine' var)
-    target - the 'target' the layer will be based on, must be one in
-           scripts/lib/bsp/substrate/target/arch
-    scripts_path - absolute path to yocto /scripts dir
-    layer_output_dir - dirname to create for layer
-    codedump - dump generated code to bspgen.out
-    properties_file - use values from this file if nonempty i.e no prompting
-    properties_str - use values from this string if nonempty i.e no prompting
-    expand_common - boolean, use the contents of (for bsp layers) arch/common
-    """
-    if os.path.exists(layer_output_dir):
-        print("\nlayer output dir already exists, exiting. (%s)" % layer_output_dir)
-        sys.exit(1)
-
-    properties = None
-
-    if properties_file:
-        try:
-            infile = open(properties_file, "r")
-            properties = json.load(infile)
-        except IOError:
-            print("Couldn't open properties file %s for reading, exiting" % properties_file)
-            sys.exit(1)
-        except ValueError:
-            print("Wrong format on properties file %s, exiting" % properties_file)
-            sys.exit(1)
-
-    if properties_str and not properties:
-        properties = json.loads(properties_str)
-
-    os.mkdir(layer_output_dir)
-
-    context = create_context(machine, target, scripts_path)
-    target_files = expand_targets(context, layer_output_dir, expand_common)
-
-    input_lines = gather_inputlines(target_files)
-
-    program_lines = []
-
-    gen_program_header_lines(program_lines)
-
-    gen_initial_property_vals(input_lines, program_lines)
-
-    if properties:
-        gen_supplied_property_vals(properties, program_lines)
-
-    gen_program_machine_lines(machine, program_lines)
-
-    if not properties:
-        gen_program_input_lines(input_lines, program_lines, context)
-
-    gen_program_lines(target_files, program_lines)
-
-    run_program_lines(program_lines, codedump)
-
-
-def yocto_layer_create(layer_name, scripts_path, layer_output_dir, codedump, properties_file, properties=""):
-    """
-    Create yocto layer
-
-    layer_name - user-defined layer name
-    scripts_path - absolute path to yocto /scripts dir
-    layer_output_dir - dirname to create for layer
-    codedump - dump generated code to bspgen.out
-    properties_file - use values from this file if nonempty i.e no prompting
-    properties - use values from this string if nonempty i.e no prompting
-    """
-    yocto_common_create(layer_name, "layer", scripts_path, layer_output_dir, codedump, properties_file, properties, False)
-
-    print("\nNew layer created in %s.\n" % layer_output_dir)
-    print("Don't forget to add it to your BBLAYERS (for details see %s/README)." % layer_output_dir)
-
-
-def yocto_bsp_create(machine, arch, scripts_path, bsp_output_dir, codedump, properties_file, properties=None):
-    """
-    Create bsp
-
-    machine - user-defined machine name
-    arch - the arch the bsp will be based on, must be one in
-           scripts/lib/bsp/substrate/target/arch
-    scripts_path - absolute path to yocto /scripts dir
-    bsp_output_dir - dirname to create for BSP
-    codedump - dump generated code to bspgen.out
-    properties_file - use values from this file if nonempty i.e no prompting
-    properties - use values from this string if nonempty i.e no prompting
-    """
-    yocto_common_create(machine, arch, scripts_path, bsp_output_dir, codedump, properties_file, properties)
-
-    print("\nNew %s BSP created in %s" % (arch, bsp_output_dir))
-
-
-def print_dict(items, indent = 0):
-    """
-    Print the values in a possibly nested dictionary.
-    """
-    for key, val in items.items():
-        print("    "*indent + "\"%s\" :" % key)
-        if type(val) == dict:
-            print("{")
-            print_dict(val, indent + 1)
-            print("    "*indent + "}")
-        else:
-            print("%s" % val)
-
-
-def get_properties(input_lines):
-    """
-    Get the complete set of properties for all the input items in the
-    BSP, as a possibly nested dictionary.
-    """
-    properties = {}
-
-    for line in input_lines:
-        if isinstance(line, InputLineGroup):
-            statement = line.group[0].line
-            group_properties = get_properties(line.group)
-            properties[statement] = group_properties
-            continue
-
-        if not isinstance(line, InputLine):
-            continue
-
-        if isinstance(line, ChoiceInputLine):
-            continue
-
-        props = line.props
-        item = {}
-        name = props["name"]
-        for key, val in props.items():
-            if not key == "name":
-                item[key] = val
-        properties[name] = item
-
-    return properties
-
-
-def yocto_layer_list_properties(arch, scripts_path, properties_file, expand_common=True):
-    """
-    List the complete set of properties for all the input items in the
-    layer.  If properties_file is non-null, write the complete set of
-    properties as a nested JSON object corresponding to a possibly
-    nested dictionary.
-    """
-    context = create_context("unused", arch, scripts_path)
-    target_files = expand_targets(context, "unused", expand_common)
-
-    input_lines = gather_inputlines(target_files)
-
-    properties = get_properties(input_lines)
-    if properties_file:
-        try:
-            of = open(properties_file, "w")
-        except IOError:
-            print("Couldn't open properties file %s for writing, exiting" % properties_file)
-            sys.exit(1)
-
-        json.dump(properties, of, indent=1)
-    else:
-        print_dict(properties)
-
-
-def split_nested_property(property):
-    """
-    A property name of the form x.y describes a nested property
-    i.e. the property y is contained within x and can be addressed
-    using standard JSON syntax for nested properties.  Note that if a
-    property name itself contains '.', it should be contained in
-    double quotes.
-    """
-    splittable_property = ""
-    in_quotes = False
-    for c in property:
-        if c == '.' and not in_quotes:
-            splittable_property += '\n'
-            continue
-        if c == '"':
-            in_quotes = not in_quotes
-        splittable_property += c
-
-    split_properties = splittable_property.split('\n')
-
-    if len(split_properties) > 1:
-        return split_properties
-
-    return None
-
-
-def find_input_line_group(substring, input_lines):
-    """
-    Find and return the InputLineGroup containing the specified substring.
-    """
-    for line in input_lines:
-        if isinstance(line, InputLineGroup):
-            if substring in line.group[0].line:
-                return line
-
-    return None
-
-
-def find_input_line(name, input_lines):
-    """
-    Find the input line with the specified name.
-    """
-    for line in input_lines:
-        if isinstance(line, InputLineGroup):
-            l = find_input_line(name, line.group)
-            if l:
-                return l
-
-        if isinstance(line, InputLine):
-            try:
-                if line.props["name"] == name:
-                    return line
-                if line.props["name"] + "_" + line.props["nameappend"] == name:
-                    return line
-            except KeyError:
-                pass
-
-    return None
-
-
-def print_values(type, values_list):
-    """
-    Print the values in the given list of values.
-    """
-    if type == "choicelist":
-        for value in values_list:
-            print("[\"%s\", \"%s\"]" % (value[0], value[1]))
-    elif type == "boolean":
-        for value in values_list:
-            print("[\"%s\", \"%s\"]" % (value[0], value[1]))
-
-
-def yocto_layer_list_property_values(arch, property, scripts_path, properties_file, expand_common=True):
-    """
-    List the possible values for a given input property.  If
-    properties_file is non-null, write the complete set of properties
-    as a JSON object corresponding to an array of possible values.
-    """
-    context = create_context("unused", arch, scripts_path)
-    context["name"] = property
-
-    target_files = expand_targets(context, "unused", expand_common)
-
-    input_lines = gather_inputlines(target_files)
-
-    properties = get_properties(input_lines)
-
-    nested_properties = split_nested_property(property)
-    if nested_properties:
-        # currently the outer property of a nested property always
-        # corresponds to an input line group
-        input_line_group = find_input_line_group(nested_properties[0], input_lines)
-        if input_line_group:
-            input_lines[:] = input_line_group.group[1:]
-            # The inner property of a nested property name is the
-            # actual property name we want, so reset to that
-            property = nested_properties[1]
-
-    input_line = find_input_line(property, input_lines)
-    if not input_line:
-        print("Couldn't find values for property %s" % property)
-        return
-
-    values_list = []
-
-    type = input_line.props["type"]
-    if type == "boolean":
-        values_list.append(["y", "n"])
-    elif type == "choicelist" or type == "checklist":
-        try:
-            gen_fn = input_line.props["gen"]
-            if nested_properties:
-                context["filename"] = nested_properties[0]
-                try:
-                    context["branches_base"] = input_line.props["branches_base"]
-                except KeyError:
-                    context["branches_base"] = None
-            values_list = input_line.gen_choices_list(context, False)
-        except KeyError:
-            for choice in input_line.choices:
-                choicepair = []
-                choicepair.append(choice.val)
-                choicepair.append(choice.desc)
-                values_list.append(choicepair)
-
-    if properties_file:
-        try:
-            of = open(properties_file, "w")
-        except IOError:
-            print("Couldn't open properties file %s for writing, exiting" % properties_file)
-            sys.exit(1)
-
-        json.dump(values_list, of)
-
-    print_values(type, values_list)
-
-
-def yocto_bsp_list(args, scripts_path):
-    """
-    Print available architectures, or the complete list of properties
-    defined by the BSP, or the possible values for a particular BSP
-    property.
-    """
-    if args.karch == "karch":
-        lib_path = scripts_path + '/lib'
-        bsp_path = lib_path + '/bsp'
-        arch_path = bsp_path + '/substrate/target/arch'
-        print("Architectures available:")
-        for arch in os.listdir(arch_path):
-            if arch == "common" or arch == "layer":
-                continue
-            print("    %s" % arch)
-        return
-
-    if args.properties:
-        yocto_layer_list_properties(args.karch, scripts_path, args.properties_file)
-    elif args.property:
-        yocto_layer_list_property_values(args.karch, args.property, scripts_path, args.properties_file)
-
-
-
-def yocto_layer_list(args, scripts_path, properties_file):
-    """
-    Print the complete list of input properties defined by the layer,
-    or the possible values for a particular layer property.
-    """
-    if len(args) < 1:
-        return False
-
-    if len(args) < 1 or len(args) > 2:
-        return False
-
-    if len(args) == 1:
-        if args[0] == "properties":
-            yocto_layer_list_properties("layer", scripts_path, properties_file, False)
-        else:
-            return False
-
-    if len(args) == 2:
-        if args[0] == "property":
-            yocto_layer_list_property_values("layer", args[1], scripts_path, properties_file, False)
-        else:
-            return False
-
-    return True
-
-
-def map_standard_kbranch(need_new_kbranch, new_kbranch, existing_kbranch):
-    """
-    Return the linux-yocto bsp branch to use with the specified
-    kbranch.  This handles the -standard variants for 3.4 and 3.8; the
-    other variants don't need mappings.
-    """
-    if need_new_kbranch == "y":
-        kbranch = new_kbranch
-    else:
-        kbranch = existing_kbranch
-
-    if kbranch.startswith("standard/common-pc-64"):
-        return "bsp/common-pc-64/common-pc-64-standard.scc"
-    if kbranch.startswith("standard/common-pc"):
-        return "bsp/common-pc/common-pc-standard.scc"
-    else:
-        return "ktypes/standard/standard.scc"
-
-
-def map_preempt_rt_kbranch(need_new_kbranch, new_kbranch, existing_kbranch):
-    """
-    Return the linux-yocto bsp branch to use with the specified
-    kbranch.  This handles the -preempt-rt variants for 3.4 and 3.8;
-    the other variants don't need mappings.
-    """
-    if need_new_kbranch == "y":
-        kbranch = new_kbranch
-    else:
-        kbranch = existing_kbranch
-
-    if kbranch.startswith("standard/preempt-rt/common-pc-64"):
-        return "bsp/common-pc-64/common-pc-64-preempt-rt.scc"
-    if kbranch.startswith("standard/preempt-rt/common-pc"):
-        return "bsp/common-pc/common-pc-preempt-rt.scc"
-    else:
-        return "ktypes/preempt-rt/preempt-rt.scc"
-
-
-def map_tiny_kbranch(need_new_kbranch, new_kbranch, existing_kbranch):
-    """
-    Return the linux-yocto bsp branch to use with the specified
-    kbranch.  This handles the -tiny variants for 3.4 and 3.8; the
-    other variants don't need mappings.
-    """
-    if need_new_kbranch == "y":
-        kbranch = new_kbranch
-    else:
-        kbranch = existing_kbranch
-
-    if kbranch.startswith("standard/tiny/common-pc"):
-        return "bsp/common-pc/common-pc-tiny.scc"
-    else:
-        return "ktypes/tiny/tiny.scc"