Currently bitbake only adds files to its dependency list if they exist. If you add 'include foo.inc' to your recipe and the file doesn't exist, then later you add the file, the cache will not be invalidated. This leads to another bug which is that if files don't exist and then you add them and they should be found first due to BBPATH, again the cache won't invalidate. This patch adds in tracking of files we check for the existence of so that if they are added later, the cache correctly invalidates. This necessitated a new version of bb.utils.which which returns a list of files tested for. The patch also adds in checks for duplicate file includes and for now prints a warning about this. That will likely become a fatal error at some point since its never usually desired to include a file twice. The same issue is also fixed for class inheritance. Now when a class is added which would be found in the usual search path, it will cause the cache to be invalidated. Unfortunately this is old code in bitbake and the patch isn't the neatest since we have to work within that framework. [YOCTO #5611] [YOCTO #4425] (Bitbake rev: 78d285871e4b8c54ccc4602d571e85f922e37ccd) Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
158 lines
4.5 KiB
Python
158 lines
4.5 KiB
Python
"""
|
|
BitBake Parsers
|
|
|
|
File parsers for the BitBake build tools.
|
|
|
|
"""
|
|
|
|
|
|
# Copyright (C) 2003, 2004 Chris Larson
|
|
# Copyright (C) 2003, 2004 Phil Blundell
|
|
#
|
|
# 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
|
|
|
|
handlers = []
|
|
|
|
import os
|
|
import stat
|
|
import logging
|
|
import bb
|
|
import bb.utils
|
|
import bb.siggen
|
|
|
|
logger = logging.getLogger("BitBake.Parsing")
|
|
|
|
class ParseError(Exception):
|
|
"""Exception raised when parsing fails"""
|
|
def __init__(self, msg, filename, lineno=0):
|
|
self.msg = msg
|
|
self.filename = filename
|
|
self.lineno = lineno
|
|
Exception.__init__(self, msg, filename, lineno)
|
|
|
|
def __str__(self):
|
|
if self.lineno:
|
|
return "ParseError at %s:%d: %s" % (self.filename, self.lineno, self.msg)
|
|
else:
|
|
return "ParseError in %s: %s" % (self.filename, self.msg)
|
|
|
|
class SkipPackage(Exception):
|
|
"""Exception raised to skip this package"""
|
|
|
|
__mtime_cache = {}
|
|
def cached_mtime(f):
|
|
if f not in __mtime_cache:
|
|
__mtime_cache[f] = os.stat(f)[stat.ST_MTIME]
|
|
return __mtime_cache[f]
|
|
|
|
def cached_mtime_noerror(f):
|
|
if f not in __mtime_cache:
|
|
try:
|
|
__mtime_cache[f] = os.stat(f)[stat.ST_MTIME]
|
|
except OSError:
|
|
return 0
|
|
return __mtime_cache[f]
|
|
|
|
def update_mtime(f):
|
|
__mtime_cache[f] = os.stat(f)[stat.ST_MTIME]
|
|
return __mtime_cache[f]
|
|
|
|
def mark_dependency(d, f):
|
|
if f.startswith('./'):
|
|
f = "%s/%s" % (os.getcwd(), f[2:])
|
|
deps = (d.getVar('__depends') or [])
|
|
s = (f, cached_mtime_noerror(f))
|
|
if s not in deps:
|
|
deps.append(s)
|
|
d.setVar('__depends', deps)
|
|
|
|
def check_dependency(d, f):
|
|
s = (f, cached_mtime_noerror(f))
|
|
deps = (d.getVar('__depends') or [])
|
|
return s in deps
|
|
|
|
def supports(fn, data):
|
|
"""Returns true if we have a handler for this file, false otherwise"""
|
|
for h in handlers:
|
|
if h['supports'](fn, data):
|
|
return 1
|
|
return 0
|
|
|
|
def handle(fn, data, include = 0):
|
|
"""Call the handler that is appropriate for this file"""
|
|
for h in handlers:
|
|
if h['supports'](fn, data):
|
|
with data.inchistory.include(fn):
|
|
return h['handle'](fn, data, include)
|
|
raise ParseError("not a BitBake file", fn)
|
|
|
|
def init(fn, data):
|
|
for h in handlers:
|
|
if h['supports'](fn):
|
|
return h['init'](data)
|
|
|
|
def init_parser(d):
|
|
bb.parse.siggen = bb.siggen.init(d)
|
|
|
|
def resolve_file(fn, d):
|
|
if not os.path.isabs(fn):
|
|
bbpath = d.getVar("BBPATH", True)
|
|
newfn, attempts = bb.utils.which(bbpath, fn, history=True)
|
|
for af in attempts:
|
|
mark_dependency(d, af)
|
|
if not newfn:
|
|
raise IOError("file %s not found in %s" % (fn, bbpath))
|
|
fn = newfn
|
|
|
|
mark_dependency(d, fn)
|
|
if not os.path.isfile(fn):
|
|
raise IOError("file %s not found" % fn)
|
|
|
|
logger.debug(2, "LOAD %s", fn)
|
|
return fn
|
|
|
|
# Used by OpenEmbedded metadata
|
|
__pkgsplit_cache__={}
|
|
def vars_from_file(mypkg, d):
|
|
if not mypkg:
|
|
return (None, None, None)
|
|
if mypkg in __pkgsplit_cache__:
|
|
return __pkgsplit_cache__[mypkg]
|
|
|
|
myfile = os.path.splitext(os.path.basename(mypkg))
|
|
parts = myfile[0].split('_')
|
|
__pkgsplit_cache__[mypkg] = parts
|
|
if len(parts) > 3:
|
|
raise ParseError("Unable to generate default variables from filename (too many underscores)", mypkg)
|
|
exp = 3 - len(parts)
|
|
tmplist = []
|
|
while exp != 0:
|
|
exp -= 1
|
|
tmplist.append(None)
|
|
parts.extend(tmplist)
|
|
return parts
|
|
|
|
def get_file_depends(d):
|
|
'''Return the dependent files'''
|
|
dep_files = []
|
|
depends = d.getVar('__base_depends', True) or []
|
|
depends = depends + (d.getVar('__depends', True) or [])
|
|
for (fn, _) in depends:
|
|
dep_files.append(os.path.abspath(fn))
|
|
return " ".join(dep_files)
|
|
|
|
from bb.parse.parse_py import __version__, ConfHandler, BBHandler
|