bitbake: Add in code to support the BBCLASSEXTEND variable. Virtual native/sdk recipes then become possible

bitbake-dev/bin/bitdoc

@@ -453,6 +453,8 @@ def main():
     except bb.parse.ParseError:
         bb.fatal( "Unable to parse %s" % config_file )
 
+    if isinstance(documentation, dict):
+        documentation = documentation[""]
 
     # Assuming we've the file loaded now, we will initialize the 'tree'
     doc = Documentation()

bitbake-dev/lib/bb/cooker.py

@@ -628,13 +628,10 @@ class BBCooker:
         fn = self.matchFile(buildfile)
         self.buildSetVars()
 
-        # Load data into the cache for fn
+        # Load data into the cache for fn and parse the loaded cache data
         self.bb_cache = bb.cache.init(self)
-        self.bb_cache.loadData(fn, self.configuration.data)      
-
-        # Parse the loaded cache data
         self.status = bb.cache.CacheData()
-        self.bb_cache.handle_data(fn, self.status)  
+        self.bb_cache.loadData(fn, self.configuration.data, self.status)      
 
         # Tweak some variables
         item = self.bb_cache.getVar('PN', fn, True)

bitbake/lib/bb/cache.py

@@ -63,7 +63,7 @@ class Cache:
 
         self.has_cache = True
         self.cachefile = os.path.join(self.cachedir,"bb_cache.dat")
-            
+
         bb.msg.debug(1, bb.msg.domain.Cache, "Using cache in '%s'" % self.cachedir)
         try:
             os.stat( self.cachedir )
@@ -125,30 +125,59 @@ class Cache:
         self.depends_cache[fn][var] = result
         return result
 
-    def setData(self, fn, data):
+    def setData(self, virtualfn, fn, data):
         """
         Called to prime bb_cache ready to learn which variables to cache.
         Will be followed by calls to self.getVar which aren't cached
         but can be fulfilled from self.data.
         """
-        self.data_fn = fn
+        self.data_fn = virtualfn
         self.data = data
 
         # Make sure __depends makes the depends_cache
-        self.getVar("__depends", fn, True)
+        self.getVar("__depends", virtualfn, True)
-        self.depends_cache[fn]["CACHETIMESTAMP"] = bb.parse.cached_mtime(fn)
+        self.depends_cache[virtualfn]["CACHETIMESTAMP"] = bb.parse.cached_mtime(fn)
 
-    def loadDataFull(self, fn, cfgData):
+    def virtualfn2realfn(self, virtualfn):
+        """
+        Convert a virtual file name to a real one + the associated subclass keyword
+        """
+
+        fn = virtualfn
+        cls = ""
+        if virtualfn.startswith('virtual:'):
+            cls = virtualfn.split(':', 2)[1]
+            fn = virtualfn.replace('virtual:' + cls + ':', '')
+        #bb.msg.debug(2, bb.msg.domain.Cache, "virtualfn2realfn %s to %s %s" % (virtualfn, fn, cls))
+        return (fn, cls)
+
+    def realfn2virtual(self, realfn, cls):
+        """
+        Convert a real filename + the associated subclass keyword to a virtual filename
+        """
+        if cls == "":
+            #bb.msg.debug(2, bb.msg.domain.Cache, "realfn2virtual %s and '%s' to %s" % (realfn, cls, realfn))
+            return realfn
+        #bb.msg.debug(2, bb.msg.domain.Cache, "realfn2virtual %s and %s to %s" % (realfn, cls, "virtual:" + cls + ":" + realfn))
+        return "virtual:" + cls + ":" + realfn
+
+    def loadDataFull(self, virtualfn, cfgData):
         """
         Return a complete set of data for fn.
         To do this, we need to parse the file.
         """
+
+        (fn, cls) = self.virtualfn2realfn(virtualfn)
+
         bb.msg.debug(1, bb.msg.domain.Cache, "Parsing %s (full)" % fn)
 
         bb_data, skipped = self.load_bbfile(fn, cfgData)
+        if isinstance(bb_data, dict):
+            return bb_data[cls]
+
         return bb_data
 
-    def loadData(self, fn, cfgData):
+    def loadData(self, fn, cfgData, cacheData):
         """
         Load a subset of data for fn.
         If the cached data is valid we do nothing,
@@ -161,12 +190,36 @@ class Cache:
         if self.cacheValid(fn):
             if "SKIPPED" in self.depends_cache[fn]:
                 return True, True
+            self.handle_data(fn, cacheData)
+            multi = self.getVar('BBCLASSEXTEND', fn, True)
+            if multi:
+                for cls in multi.split():
+                    virtualfn = self.realfn2virtual(fn, cls)
+                    # Pretend we're clean so getVar works
+                    self.clean[virtualfn] = ""
+                    self.handle_data(virtualfn, cacheData)
             return True, False
 
         bb.msg.debug(1, bb.msg.domain.Cache, "Parsing %s" % fn)
 
         bb_data, skipped = self.load_bbfile(fn, cfgData)
-        self.setData(fn, bb_data)
+
+        if skipped:
+           if isinstance(bb_data, dict):
+               self.setData(fn, fn, bb_data[""])
+           else:
+               self.setData(fn, fn, bb_data)
+           return False, skipped
+
+        if isinstance(bb_data, dict):
+            for data in bb_data:
+                virtualfn = self.realfn2virtual(fn, data)
+                self.setData(virtualfn, fn, bb_data[data])
+                self.handle_data(virtualfn, cacheData)
+            return False, skipped
+
+        self.setData(fn, fn, bb_data)
+        self.handle_data(fn, cacheData)
         return False, skipped
 
     def cacheValid(self, fn):
@@ -384,6 +437,7 @@ class Cache:
 
         # Touch this to make sure its in the cache
         self.getVar('__BB_DONT_CACHE', file_name, True)
+        self.getVar('BBCLASSEXTEND', file_name, True)
 
     def load_bbfile( self, bbfile , config):
         """

bitbake/lib/bb/cooker.py

@@ -475,13 +475,10 @@ class BBCooker:
         if not fn:
             return False
 
-        # Load data into the cache for fn
+        # Load data into the cache for fn and parse the loaded cache data
         self.bb_cache = bb.cache.init(self)
-        self.bb_cache.loadData(fn, self.configuration.data)
-
-        # Parse the loaded cache data
         self.status = bb.cache.CacheData()
-        self.bb_cache.handle_data(fn, self.status)
+        self.bb_cache.loadData(fn, self.configuration.data, self.status)
 
         # Tweak some variables
         item = self.bb_cache.getVar('PN', fn, True)
@@ -723,7 +720,7 @@ class BBCooker:
 
             # read a file's metadata
             try:
-                fromCache, skip = self.bb_cache.loadData(f, self.configuration.data)
+                fromCache, skip = self.bb_cache.loadData(f, self.configuration.data, self.status)
                 if skip:
                     skipped += 1
                     bb.msg.debug(2, bb.msg.domain.Collection, "skipping %s" % f)
@@ -731,7 +728,6 @@ class BBCooker:
                     continue
                 elif fromCache: cached += 1
                 else: parsed += 1
-                deps = None
 
                 # Disabled by RP as was no longer functional
                 # allow metadata files to add items to BBFILES
@@ -744,8 +740,6 @@ class BBCooker:
                 #                aof = os.path.join(os.path.dirname(f),aof)
                 #            files.append(aof)
 
-                self.bb_cache.handle_data(f, self.status)
-
                 # now inform the caller
                 if progressCallback is not None:
                     progressCallback( i + 1, len( filelist ), f, fromCache )

bitbake/lib/bb/parse/parse_py/BBHandler.py

@@ -181,7 +181,21 @@ def handle(fn, d, include = 0):
         classes.remove(__classname__)
     else:
         if include == 0:
-            finalise(fn, d)
+            multi = data.getVar('BBCLASSEXTEND', d, 1)
+            if multi:
+                based = bb.data.createCopy(d)
+                finalise(fn, based)
+                darray = {"": based}
+                for cls in multi.split():
+                    pn = data.getVar('PN', d, True)
+                    based = bb.data.createCopy(d)
+                    data.setVar('PN', pn + '-' + cls, based)
+                    inherit([cls], based)
+                    finalise(fn, based)
+                    darray[cls] = based
+                return darray
+            else:
+                finalise(fn, d)
         bbpath.pop(0)
     if oldfile:
         bb.data.setVar("FILE", oldfile, d)

bitbake/lib/bb/shell.py

@@ -276,7 +276,7 @@ class BitBakeShellCommands:
         print "SHELL: Parsing '%s'" % bbfile
         parse.update_mtime( bbfile )
         cooker.bb_cache.cacheValidUpdate(bbfile)
-        fromCache = cooker.bb_cache.loadData(bbfile, cooker.configuration.data)
+        fromCache = cooker.bb_cache.loadData(bbfile, cooker.configuration.data, cooker.status)
         cooker.bb_cache.sync()
         if False: #fromCache:
             print "SHELL: File has not been updated, not reparsing"