Ticket #5454: FileRules-Rule-UntarArchive-v3.patch

build/jam/FileRules

@@ -238 +238 @@
 
     # Use a dummy rule so that it looks to jam like the targets are actually
     # built from the directory target.
-    UnzipArchiveDummy $(targets) : $(directory) ;
+    UnArchiveDummy $(targets) : $(directory) ;
 
     return $(targets) ;
 }
@@ -249 +249 @@
     unzip -q -u -o -d $(1[1]) $(2)
 }
 
-actions UnzipArchiveDummy
+actions UnArchiveDummy
 {
 }
 
+rule UntarArchive directory : entries : tarFile : grist
+{
+    # UntarArchive <directory> : <entries> : <tarFile> [ : <grist> ]
+    #
+    # Untars the tar file target <tarFile> to directory <directory>. The rule
+    # can be called multiple times for different <entries> for the same
+    # <directory> and <tarFile> combo.
+    #
+    # <directory> - The directory into which to untar the tar file. The
+    #               directory is created is by this rule and it is the target
+    #               that the untar action is associated with.
+    # <entries>   - The entries of the tar file one is interested in. The rule
+    #               always untars the complete tar file, from the given entries
+    #               the rule creates targets (using <grist>) representing the
+    #               untarred entries. Those targets are returned by the rule.
+    # <tarFile>   - The tar file target to untar.
+    # <grist>     - The grist used to create targets from <entries>. Defaults to
+    #               "untarred".
 
+    grist ?= untarred ;
+
+    # Turn the entries into targets to build.
+    local targets ;
+    local entry ;
+    for entry in $(entries) {
+        local target = $(entry:G=$(grist)) ;
+        targets += $(target) ;
+    }
+
+    LOCATE on $(targets) = $(directory) ;
+    Depends $(targets) : $(directory) ;
+    NoUpdate $(targets) ;
+
+    # one-time initialization for the main target (the directory)
+    if ! [ on $(directory) return $(INITIALIZED) ] {
+        # make sure the parent dir exists
+        local parentDir = $(directory:PG=dir) ;
+        Depends $(directory) : $(parentDir) ;
+        MkDir $(parentDir) ;
+
+        NoUpdate $(directory) ;
+        Depends $(directory) : $(tarFile) ;
+        UntarArchive1 $(directory) : $(tarFile) ;
+        INITIALIZED on $(directory) = 1 ;
+    }
+
+    # Use a dummy rule so that it looks to jam like the targets are actually
+    # built from the directory target.
+    UnArchiveDummy $(targets) : $(directory) ;
+
+    return $(targets) ;
+}
+
+actions UntarArchive1
+{
+    mkdir -p $(1[1])
+    tar -C $(1[1]) -xf $(2)
+}
+
 rule ObjectReference
 {
     # ObjectReference <reference object> : <source object>