[Subtree] Removing import-layers directory

As part of the move to subtrees, need to bring all the import layers
content to the top level.

Change-Id: I4a163d10898cbc6e11c27f776f60e1a470049d8f
Signed-off-by: Dave Cobbley <david.j.cobbley@linux.intel.com>
Signed-off-by: Brad Bishop <bradleyb@fuzziesquirrel.com>

1 files changed, 0 insertions, 403 deletions

diff --git a/import-layers/yocto-poky/bitbake/lib/bb/data.py b/import-layers/yocto-poky/bitbake/lib/bb/data.py
deleted file mode 100644
index 80a7879cb..000000000
--- a/import-layers/yocto-poky/bitbake/lib/bb/data.py
+++ /dev/null
@@ -1,403 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Data' implementations
-
-Functions for interacting with the data structure used by the
-BitBake build tools.
-
-The expandKeys and update_data are the most expensive
-operations. At night the cookie monster came by and
-suggested 'give me cookies on setting the variables and
-things will work out'. Taking this suggestion into account
-applying the skills from the not yet passed 'Entwurf und
-Analyse von Algorithmen' lecture and the cookie
-monster seems to be right. We will track setVar more carefully
-to have faster update_data and expandKeys operations.
-
-This is a trade-off between speed and memory again but
-the speed is more critical here.
-"""
-
-# Copyright (C) 2003, 2004  Chris Larson
-# Copyright (C) 2005        Holger Hans Peter Freyther
-#
-# 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.
-#
-# Based on functions from the base bb module, Copyright 2003 Holger Schurig
-
-import sys, os, re
-if sys.argv[0][-5:] == "pydoc":
-    path = os.path.dirname(os.path.dirname(sys.argv[1]))
-else:
-    path = os.path.dirname(os.path.dirname(sys.argv[0]))
-sys.path.insert(0, path)
-from itertools import groupby
-
-from bb import data_smart
-from bb import codeparser
-import bb
-
-logger = data_smart.logger
-_dict_type = data_smart.DataSmart
-
-def init():
-    """Return a new object representing the Bitbake data"""
-    return _dict_type()
-
-def init_db(parent = None):
-    """Return a new object representing the Bitbake data,
-    optionally based on an existing object"""
-    if parent is not None:
-        return parent.createCopy()
-    else:
-        return _dict_type()
-
-def createCopy(source):
-    """Link the source set to the destination
-    If one does not find the value in the destination set,
-    search will go on to the source set to get the value.
-    Value from source are copy-on-write. i.e. any try to
-    modify one of them will end up putting the modified value
-    in the destination set.
-    """
-    return source.createCopy()
-
-def initVar(var, d):
-    """Non-destructive var init for data structure"""
-    d.initVar(var)
-
-def keys(d):
-    """Return a list of keys in d"""
-    return d.keys()
-
-
-__expand_var_regexp__ = re.compile(r"\${[^{}]+}")
-__expand_python_regexp__ = re.compile(r"\${@.+?}")
-
-def expand(s, d, varname = None):
-    """Variable expansion using the data store"""
-    return d.expand(s, varname)
-
-def expandKeys(alterdata, readdata = None):
-    if readdata == None:
-        readdata = alterdata
-
-    todolist = {}
-    for key in alterdata:
-        if not '${' in key:
-            continue
-
-        ekey = expand(key, readdata)
-        if key == ekey:
-            continue
-        todolist[key] = ekey
-
-    # These two for loops are split for performance to maximise the
-    # usefulness of the expand cache
-    for key in sorted(todolist):
-        ekey = todolist[key]
-        newval = alterdata.getVar(ekey, False)
-        if newval is not None:
-            val = alterdata.getVar(key, False)
-            if val is not None:
-                bb.warn("Variable key %s (%s) replaces original key %s (%s)." % (key, val, ekey, newval))
-        alterdata.renameVar(key, ekey)
-
-def inheritFromOS(d, savedenv, permitted):
-    """Inherit variables from the initial environment."""
-    exportlist = bb.utils.preserved_envvars_exported()
-    for s in savedenv.keys():
-        if s in permitted:
-            try:
-                d.setVar(s, savedenv.getVar(s), op = 'from env')
-                if s in exportlist:
-                    d.setVarFlag(s, "export", True, op = 'auto env export')
-            except TypeError:
-                pass
-
-def emit_var(var, o=sys.__stdout__, d = init(), all=False):
-    """Emit a variable to be sourced by a shell."""
-    func = d.getVarFlag(var, "func", False)
-    if d.getVarFlag(var, 'python', False) and func:
-        return False
-
-    export = d.getVarFlag(var, "export", False)
-    unexport = d.getVarFlag(var, "unexport", False)
-    if not all and not export and not unexport and not func:
-        return False
-
-    try:
-        if all:
-            oval = d.getVar(var, False)
-        val = d.getVar(var)
-    except (KeyboardInterrupt, bb.build.FuncFailed):
-        raise
-    except Exception as exc:
-        o.write('# expansion of %s threw %s: %s\n' % (var, exc.__class__.__name__, str(exc)))
-        return False
-
-    if all:
-        d.varhistory.emit(var, oval, val, o, d)
-
-    if (var.find("-") != -1 or var.find(".") != -1 or var.find('{') != -1 or var.find('}') != -1 or var.find('+') != -1) and not all:
-        return False
-
-    varExpanded = d.expand(var)
-
-    if unexport:
-        o.write('unset %s\n' % varExpanded)
-        return False
-
-    if val is None:
-        return False
-
-    val = str(val)
-
-    if varExpanded.startswith("BASH_FUNC_"):
-        varExpanded = varExpanded[10:-2]
-        val = val[3:] # Strip off "() "
-        o.write("%s() %s\n" % (varExpanded, val))
-        o.write("export -f %s\n" % (varExpanded))
-        return True
-
-    if func:
-        # NOTE: should probably check for unbalanced {} within the var
-        val = val.rstrip('\n')
-        o.write("%s() {\n%s\n}\n" % (varExpanded, val))
-        return 1
-
-    if export:
-        o.write('export ')
-
-    # if we're going to output this within doublequotes,
-    # to a shell, we need to escape the quotes in the var
-    alter = re.sub('"', '\\"', val)
-    alter = re.sub('\n', ' \\\n', alter)
-    alter = re.sub('\\$', '\\\\$', alter)
-    o.write('%s="%s"\n' % (varExpanded, alter))
-    return False
-
-def emit_env(o=sys.__stdout__, d = init(), all=False):
-    """Emits all items in the data store in a format such that it can be sourced by a shell."""
-
-    isfunc = lambda key: bool(d.getVarFlag(key, "func", False))
-    keys = sorted((key for key in d.keys() if not key.startswith("__")), key=isfunc)
-    grouped = groupby(keys, isfunc)
-    for isfunc, keys in grouped:
-        for key in sorted(keys):
-            emit_var(key, o, d, all and not isfunc) and o.write('\n')
-
-def exported_keys(d):
-    return (key for key in d.keys() if not key.startswith('__') and
-                                      d.getVarFlag(key, 'export', False) and
-                                      not d.getVarFlag(key, 'unexport', False))
-
-def exported_vars(d):
-    k = list(exported_keys(d))
-    for key in k:
-        try:
-            value = d.getVar(key)
-        except Exception as err:
-            bb.warn("%s: Unable to export ${%s}: %s" % (d.getVar("FILE"), key, err))
-            continue
-
-        if value is not None:
-            yield key, str(value)
-
-def emit_func(func, o=sys.__stdout__, d = init()):
-    """Emits all items in the data store in a format such that it can be sourced by a shell."""
-
-    keys = (key for key in d.keys() if not key.startswith("__") and not d.getVarFlag(key, "func", False))
-    for key in sorted(keys):
-        emit_var(key, o, d, False)
-
-    o.write('\n')
-    emit_var(func, o, d, False) and o.write('\n')
-    newdeps = bb.codeparser.ShellParser(func, logger).parse_shell(d.getVar(func))
-    newdeps |= set((d.getVarFlag(func, "vardeps") or "").split())
-    seen = set()
-    while newdeps:
-        deps = newdeps
-        seen |= deps
-        newdeps = set()
-        for dep in deps:
-            if d.getVarFlag(dep, "func", False) and not d.getVarFlag(dep, "python", False):
-               emit_var(dep, o, d, False) and o.write('\n')
-               newdeps |=  bb.codeparser.ShellParser(dep, logger).parse_shell(d.getVar(dep))
-               newdeps |= set((d.getVarFlag(dep, "vardeps") or "").split())
-        newdeps -= seen
-
-_functionfmt = """
-def {function}(d):
-{body}"""
-
-def emit_func_python(func, o=sys.__stdout__, d = init()):
-    """Emits all items in the data store in a format such that it can be sourced by a shell."""
-
-    def write_func(func, o, call = False):
-        body = d.getVar(func, False)
-        if not body.startswith("def"):
-            body = _functionfmt.format(function=func, body=body)
-
-        o.write(body.strip() + "\n\n")
-        if call:
-            o.write(func + "(d)" + "\n\n")
-
-    write_func(func, o, True)
-    pp = bb.codeparser.PythonParser(func, logger)
-    pp.parse_python(d.getVar(func, False))
-    newdeps = pp.execs
-    newdeps |= set((d.getVarFlag(func, "vardeps") or "").split())
-    seen = set()
-    while newdeps:
-        deps = newdeps
-        seen |= deps
-        newdeps = set()
-        for dep in deps:
-            if d.getVarFlag(dep, "func", False) and d.getVarFlag(dep, "python", False):
-               write_func(dep, o)
-               pp = bb.codeparser.PythonParser(dep, logger)
-               pp.parse_python(d.getVar(dep, False))
-               newdeps |= pp.execs
-               newdeps |= set((d.getVarFlag(dep, "vardeps") or "").split())
-        newdeps -= seen
-
-def update_data(d):
-    """Performs final steps upon the datastore, including application of overrides"""
-    d.finalize(parent = True)
-
-def build_dependencies(key, keys, shelldeps, varflagsexcl, d):
-    deps = set()
-    try:
-        if key[-1] == ']':
-            vf = key[:-1].split('[')
-            value = d.getVarFlag(vf[0], vf[1], False)
-            parser = d.expandWithRefs(value, key)
-            deps |= parser.references
-            deps = deps | (keys & parser.execs)
-            return deps, value
-        varflags = d.getVarFlags(key, ["vardeps", "vardepvalue", "vardepsexclude", "exports", "postfuncs", "prefuncs", "lineno", "filename"]) or {}
-        vardeps = varflags.get("vardeps")
-        value = d.getVarFlag(key, "_content", False)
-
-        def handle_contains(value, contains, d):
-            newvalue = ""
-            for k in sorted(contains):
-                l = (d.getVar(k) or "").split()
-                for item in sorted(contains[k]):
-                    for word in item.split():
-                        if not word in l:
-                            newvalue += "\n%s{%s} = Unset" % (k, item)
-                            break
-                    else:
-                        newvalue += "\n%s{%s} = Set" % (k, item)
-            if not newvalue:
-                return value
-            if not value:
-                return newvalue
-            return value + newvalue
-
-        if "vardepvalue" in varflags:
-           value = varflags.get("vardepvalue")
-        elif varflags.get("func"):
-            if varflags.get("python"):
-                parser = bb.codeparser.PythonParser(key, logger)
-                if value and "\t" in value:
-                    logger.warning("Variable %s contains tabs, please remove these (%s)" % (key, d.getVar("FILE")))
-                parser.parse_python(value, filename=varflags.get("filename"), lineno=varflags.get("lineno"))
-                deps = deps | parser.references
-                deps = deps | (keys & parser.execs)
-                value = handle_contains(value, parser.contains, d)
-            else:
-                parsedvar = d.expandWithRefs(value, key)
-                parser = bb.codeparser.ShellParser(key, logger)
-                parser.parse_shell(parsedvar.value)
-                deps = deps | shelldeps
-                deps = deps | parsedvar.references
-                deps = deps | (keys & parser.execs) | (keys & parsedvar.execs)
-                value = handle_contains(value, parsedvar.contains, d)
-            if vardeps is None:
-                parser.log.flush()
-            if "prefuncs" in varflags:
-                deps = deps | set(varflags["prefuncs"].split())
-            if "postfuncs" in varflags:
-                deps = deps | set(varflags["postfuncs"].split())
-            if "exports" in varflags:
-                deps = deps | set(varflags["exports"].split())
-        else:
-            parser = d.expandWithRefs(value, key)
-            deps |= parser.references
-            deps = deps | (keys & parser.execs)
-            value = handle_contains(value, parser.contains, d)
-
-        if "vardepvalueexclude" in varflags:
-            exclude = varflags.get("vardepvalueexclude")
-            for excl in exclude.split('|'):
-                if excl:
-                    value = value.replace(excl, '')
-
-        # Add varflags, assuming an exclusion list is set
-        if varflagsexcl:
-            varfdeps = []
-            for f in varflags:
-                if f not in varflagsexcl:
-                    varfdeps.append('%s[%s]' % (key, f))
-            if varfdeps:
-                deps |= set(varfdeps)
-
-        deps |= set((vardeps or "").split())
-        deps -= set(varflags.get("vardepsexclude", "").split())
-    except bb.parse.SkipRecipe:
-        raise
-    except Exception as e:
-        bb.warn("Exception during build_dependencies for %s" % key)
-        raise
-    return deps, value
-    #bb.note("Variable %s references %s and calls %s" % (key, str(deps), str(execs)))
-    #d.setVarFlag(key, "vardeps", deps)
-
-def generate_dependencies(d):
-
-    keys = set(key for key in d if not key.startswith("__"))
-    shelldeps = set(key for key in d.getVar("__exportlist", False) if d.getVarFlag(key, "export", False) and not d.getVarFlag(key, "unexport", False))
-    varflagsexcl = d.getVar('BB_SIGNATURE_EXCLUDE_FLAGS')
-
-    deps = {}
-    values = {}
-
-    tasklist = d.getVar('__BBTASKS', False) or []
-    for task in tasklist:
-        deps[task], values[task] = build_dependencies(task, keys, shelldeps, varflagsexcl, d)
-        newdeps = deps[task]
-        seen = set()
-        while newdeps:
-            nextdeps = newdeps
-            seen |= nextdeps
-            newdeps = set()
-            for dep in nextdeps:
-                if dep not in deps:
-                    deps[dep], values[dep] = build_dependencies(dep, keys, shelldeps, varflagsexcl, d)
-                newdeps |=  deps[dep]
-            newdeps -= seen
-        #print "For %s: %s" % (task, str(deps[task]))
-    return tasklist, deps, values
-
-def inherits_class(klass, d):
-    val = d.getVar('__inherit_cache', False) or []
-    needle = os.path.join('classes', '%s.bbclass' % klass)
-    for v in val:
-        if v.endswith(needle):
-            return True
-    return False