Merge the BBCLASSEXTEND code from Poky. This allows once recipe to provide mutliple targets (e.g. -native and -sdk) and has been discussed on the OE mailing list

5 files changed, 81 insertions, 18 deletions

diff --git a/ChangeLog b/ChangeLog
index 5b2f97811..2ee0543b1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -83,6 +83,7 @@ Changes in BitBake 1.8.12:
 	  proxies to work better. (from Poky)
 	- Also allow user and pswd options in SRC_URIs globally (from Poky)
 	- Improve proxy handling when using mirrors (from Poky)
+	- Addition of BBCLASSEXTEND support for allowing one recipe to provide multiple targets (from Poky)
 
 Changes in BitBake 1.8.10:
 	- Psyco is available only for x86 - do not use it on other architectures.
diff --git a/lib/bb/cache.py b/lib/bb/cache.py
index 811e9386a..272619386 100644
--- a/lib/bb/cache.py
+++ b/lib/bb/cache.py
@@ -124,30 +124,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.depends_cache[fn]["CACHETIMESTAMP"] = bb.parse.cached_mtime(fn)
+        self.getVar("__depends", virtualfn, True)
+        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,
@@ -160,12 +189,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):
@@ -383,6 +436,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):
         """
diff --git a/lib/bb/cooker.py b/lib/bb/cooker.py
index f0f7d9ea7..d4c53c74f 100644
--- a/lib/bb/cooker.py
+++ b/lib/bb/cooker.py
@@ -474,13 +474,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)
@@ -725,7 +722,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)
@@ -733,7 +730,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
@@ -746,8 +742,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 )
diff --git a/lib/bb/parse/parse_py/BBHandler.py b/lib/bb/parse/parse_py/BBHandler.py
index 9b79338c4..d13428aa0 100644
--- a/lib/bb/parse/parse_py/BBHandler.py
+++ b/lib/bb/parse/parse_py/BBHandler.py
@@ -175,7 +175,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)
diff --git a/lib/bb/shell.py b/lib/bb/shell.py
index e436d9dbc..b1ad78306 100644
--- a/lib/bb/shell.py
+++ b/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"