Ticket #5479: 5479-ExtractArchiveToHaikuImage.patch

File 5479-ExtractArchiveToHaikuImage.patch, 13.5 KB (added by mmadia, 14 years ago)

fixed the previous broken patch due to manual editing.

  • build/jam/FileRules

     
    400401
    401402rule DownloadOptionalPackage package : url
    402403{
    403     return [ DownloadFile $(package).zip : $(url) ] ;
     404   
     405    local extension = $(url:S) ;
     406    return [ DownloadFile $(package)$(extension) : $(url) ] ;
    404407}

  • build/jam/ImageRules

     
    273273    DIRECTORIES_TO_INSTALL on $(directory) += $(targetDir) ;
    274274}
    275275
    276 rule UnzipArchiveToContainer container : directoryTokens : zipFile
     276rule ExtractArchiveToContainer container : directoryTokens : archiveFile
    277277{
    278     # UnzipArchiveToContainer <container> : <directory> : <zipFile> ] ;
     278    # ExtractArchiveToContainer <container> : <directory> : <archiveFile> ] ;
    279279    #
    280280
    281281    local directory = [ AddDirectoryToContainer $(container)
    282282        : $(directoryTokens) ] ;
    283283
    284     ZIP_FILES_TO_INSTALL on $(directory) += $(zipFile) ;
     284    ARCHIVE_FILES_TO_INSTALL on $(directory) += $(archiveFile) ;
    285285}
    286286
    287287rule AddDriversToContainer container : relativeDirectoryTokens : targets
    … …  
    560560}
    561561
    562562
    563 rule CreateContainerUnzipFilesScript container : script
     563rule CreateContainerExtractFilesScript container : script
    564564{
    565565    MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
    566566    Always $(script) ;
    … …  
    581581
    582582    local dir ;
    583583    for dir in [ on $(container) return $(HAIKU_INSTALL_DIRECTORIES) ] {
    584         local zipFiles = [ on $(dir) return $(ZIP_FILES_TO_INSTALL) ] ;
    585         local zipFile ;
    586         for zipFile in $(zipFiles) {
     584        local archiveFiles = [ on $(dir) return $(ARCHIVE_FILES_TO_INSTALL) ] ;
     585        local archiveFile ;
     586        for archiveFile in $(archiveFiles) {
    587587            # use a unique dummy target for this file, on which we
    588588            # can define the TARGET_DIR variable
    589             local dummyTarget = $(script)-dummy-$(dir:G=)-$(zipFile) ;
     589            local dummyTarget = $(script)-dummy-$(dir:G=)-$(archiveFile) ;
    590590            NotFile $(dummyTarget) ;
    591591            TARGET_DIR on $(dummyTarget) = $(dir:G=) ;
    592592
    593             Depends $(dummyTarget) : $(initScript) $(zipFile)
     593            Depends $(dummyTarget) : $(initScript) $(archiveFile)
    594594                $(serializationDependency) ;
    595595            Depends $(script) : $(dummyTarget) ;
    596596            serializationDependency = $(dummyTarget) ;
    597597
    598             AddUnzipFileToContainerUnzipFilesScript $(dummyTarget)
    599                 : $(initScript) $(zipFile) ;
     598            # Note: this would require separate & redundant functions in the
     599            # build/scripts/(build_haiku_image, build_haiku_cd)
     600            # on one hand, the script should be able to parse the file
     601            # extension inside unzipFile() renamed as extractFile().
     602            # on the other hand, i'd need to make sure it's a pure sh
     603            # implementation and not bash.
     604            #
     605            #switch $(archiveFile:S)
     606            #{
     607            #   case .zip   : AddUnzipFileToContainerExtractFilesScript
     608            #                   $(dummyTarget) : $(initScript) $(archiveFile) ;
     609            #   case .tgz   : AddUntarFileToContainerExtractFilesScript
     610            #                   $(dummyTarget) : $(initScript) $(archiveFile) ;
     611            #   case *      : Exit "CreateContainerExtractFilesScript:
     612            #                   Unhandled archive extension: $(archiveFile:S)" ;
     613            #}
     614            #
     615            AddExtractFileToContainerExtractFilesScript $(dummyTarget)
     616                : $(initScript) $(archiveFile) ;
    600617        }
    601618    }
    602619}
    603620
    604 actions AddUnzipFileToContainerUnzipFilesScript
     621
     622actions AddExtractFileToContainerExtractFilesScript
    605623{
    606     echo unzipFile "\"$(2[2])\"" "\"$(TARGET_DIR)\"" >> $(2[1])
     624    echo extractFile "\"$(2[2])\"" "\"$(TARGET_DIR)\"" >> $(2[1])
    607625}
    608626
    609627
    … …  
    690708        : $(dirName) : -x .svn : $(alwaysUpdate) ;
    691709}
    692710
    693 rule UnzipArchiveToHaikuImage dirTokens : zipFile : alwaysUpdate
     711rule ExtractArchiveToHaikuImage dirTokens : archiveFile : alwaysUpdate
    694712{
    695     # UnzipArchiveToHaikuImage <dirTokens> : <zipFile> : <alwaysUpdate> ;
     713    # ExtractArchiveToHaikuImage <dirTokens> : <archiveFile> : <alwaysUpdate> ;
    696714
    697     # If the image shall only be updated, we unzip only, if explicitely
     715    # If the image shall only be updated, we extract only, if explicitely
    698716    # requested.
    699717    if ! [ IsUpdateHaikuImageOnly ] || $(alwaysUpdate) {
    700         UnzipArchiveToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(dirTokens)
    701             : $(zipFile) ;
     718        ExtractArchiveToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(dirTokens)
     719            : $(archiveFile) ;
    702720    }
    703721}
    704722
    … …  
    771789
    772790rule InstallOptionalHaikuImagePackage package : url : dirTokens : isCDPackage
    773791{
    774     # download zip file
    775     local zipFile = [ DownloadOptionalPackage $(package) : $(url) ] ;
     792    # download archive file
     793    local archiveFile = [ DownloadOptionalPackage $(package) : $(url) ] ;
    776794
    777795    if ( $(isCDPackage) = true || $(isCDPackage) = 1 ) && $(HAIKU_CD_NAME) {
    778796        # TODO: If HAIKU_CD_NAME is set, that doesn't mean we're building a CD
    779797        # image!
    780798        # copy onto image
    781         AddFilesToHaikuImage _packages_ : $(zipFile) ;
     799        AddFilesToHaikuImage _packages_ : $(archiveFile) ;
    782800    } else {
    783         # unzip onto image
    784         UnzipArchiveToHaikuImage $(dirTokens) : $(zipFile) ;
     801        # extract onto image
     802        ExtractArchiveToHaikuImage $(dirTokens) : $(archiveFile) ;
    785803    }
    786804}
    787805
    … …  
    866884    CreateContainerCopyFilesScript $(HAIKU_IMAGE_CONTAINER_NAME) : $(script) ;
    867885}
    868886
    869 rule CreateHaikuImageUnzipFilesScript script
     887rule CreateHaikuImageExtractFilesScript script
    870888{
    871     CreateContainerUnzipFilesScript $(HAIKU_IMAGE_CONTAINER_NAME) : $(script) ;
     889    CreateContainerExtractFilesScript $(HAIKU_IMAGE_CONTAINER_NAME) : $(script) ;
    872890}
    873891
    874892rule BuildHaikuImage haikuImage : scripts : isImage : isVMwareImage

  • build/jam/OptionalBuildFeatures

     
    2828        HAIKU_OPENSSL_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
    2929            $(HAIKU_OPENSSL_PACKAGE) ] ;
    3030
    31         # unzip headers and libraries
     31        # extract headers and libraries
    3232        HAIKU_OPENSSL_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_OPENSSL_DIR)
    3333            : common/include/ : $(zipFile)
    3434        ] ;

  • build/jam/HaikuImage

     
    657657        : "haiku-alternative-gcc-archive" ;
    658658
    659659    # install the alternative libs in the right directory
    660     UnzipArchiveToHaikuImage : $(otherAlternativeSystemLibsZip) ;
     660    ExtractArchiveToHaikuImage : $(otherAlternativeSystemLibsZip) ;
    661661}
    662662
    663663
    … …  
    734734AddTargetVariableToScript $(script) : <build>rc ;
    735735AddTargetVariableToScript $(script) : <build>resattr ;
    736736AddTargetVariableToScript $(script) : <build>unzip ;
     737# TODO: Need to add tar to haiku/src/tools
     738# AddTargetVariableToScript $(script) : <build>tar ;
     739AddTargetVariableToScript $(script) : tar ;
    737740AddTargetVariableToScript $(script) : <build>vmdkimage ;
    738741if $(HOST_RM_ATTRS_TARGET) {
    739742    AddTargetVariableToScript $(script) : $(HOST_RM_ATTRS_TARGET) : rmAttrs ;
    … …  
    749752# create the other scripts
    750753HAIKU_IMAGE_MAKE_DIRS_SCRIPT = <HaikuImage>haiku.image-make-dirs ;
    751754HAIKU_IMAGE_COPY_FILES_SCRIPT = <HaikuImage>haiku.image-copy-files ;
    752 HAIKU_IMAGE_UNZIP_FILES_SCRIPT = <HaikuImage>haiku.image-unzip-files ;
     755HAIKU_IMAGE_EXTRACT_FILES_SCRIPT = <HaikuImage>haiku.image-extract-files ;
    753756MakeLocate $(HAIKU_IMAGE_MAKE_DIRS_SCRIPT) $(HAIKU_IMAGE_COPY_FILES_SCRIPT)
    754     $(HAIKU_IMAGE_UNZIP_FILES_SCRIPT) : $(HAIKU_OUTPUT_DIR) ;
     757    $(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT) : $(HAIKU_OUTPUT_DIR) ;
    755758
    756759CreateHaikuImageMakeDirectoriesScript $(HAIKU_IMAGE_MAKE_DIRS_SCRIPT) ;
    757760CreateHaikuImageCopyFilesScript $(HAIKU_IMAGE_COPY_FILES_SCRIPT) ;
    758 CreateHaikuImageUnzipFilesScript $(HAIKU_IMAGE_UNZIP_FILES_SCRIPT) ;
     761CreateHaikuImageExtractFilesScript $(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT) ;
    759762
    760763# Convenience wrapper rule around BuildHaikuImage.
    761764rule _BuildHaikuImage image : isImage : isVMwareImage
    … …  
    771774        $(HAIKU_IMAGE_EARLY_USER_SCRIPTS)
    772775        $(HAIKU_IMAGE_MAKE_DIRS_SCRIPT)
    773776        $(HAIKU_IMAGE_COPY_FILES_SCRIPT)
    774         $(HAIKU_IMAGE_UNZIP_FILES_SCRIPT)
     777        $(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT)
    775778        $(HAIKU_IMAGE_LATE_USER_SCRIPTS)
    776779        : $(isImage)
    777780        : $(isVMwareImage)
    … …  
    782785        $(HAIKU_IMAGE_INIT_VARIABLES_SCRIPT)
    783786        $(HAIKU_IMAGE_MAKE_DIRS_SCRIPT)
    784787        $(HAIKU_IMAGE_COPY_FILES_SCRIPT)
    785         $(HAIKU_IMAGE_UNZIP_FILES_SCRIPT)
     788        $(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT)
    786789    ;
    787790}
    788791

  • build/jam/HaikuCD

     
    2525AddTargetVariableToScript $(script) : <build>rc ;
    2626AddTargetVariableToScript $(script) : <build>resattr ;
    2727AddTargetVariableToScript $(script) : <build>unzip ;
     28# TODO: Need to add tar to haiku/src/tools
     29# AddTargetVariableToScript $(script) : <build>tar ;
     30AddTargetVariableToScript $(script) : tar ;
    2831AddTargetVariableToScript $(script) : <build>generate_attribute_stores ;
    2932if $(HOST_RM_ATTRS_TARGET) {
    3033    AddTargetVariableToScript $(script) : $(HOST_RM_ATTRS_TARGET) : rmAttrs ;
    … …  
    5053        $(HAIKU_IMAGE_EARLY_USER_SCRIPTS)
    5154        $(HAIKU_IMAGE_MAKE_DIRS_SCRIPT)
    5255        $(HAIKU_IMAGE_COPY_FILES_SCRIPT)
    53         $(HAIKU_IMAGE_UNZIP_FILES_SCRIPT)
     56        $(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT)
    5457        $(HAIKU_IMAGE_LATE_USER_SCRIPTS)
    5558    ;
    5659
    … …  
    5962        $(HAIKU_CD_INIT_VARIABLES_SCRIPT)
    6063        $(HAIKU_IMAGE_MAKE_DIRS_SCRIPT)
    6164        $(HAIKU_IMAGE_COPY_FILES_SCRIPT)
    62         $(HAIKU_IMAGE_UNZIP_FILES_SCRIPT)
     65        $(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT)
    6366    ;
    6467}
    6568

  • build/jam/UserBuildConfig.ReadMe

     
    122122    : $(HAIKU_TOP)/../buildtools/jam
    123123    : "jam-src" : -x .svn -X \\*/jam/./bin.\\* ;
    124124
    125 # Unzips the given zip archive onto the image under /boot/develop/tools.
    126 UnzipArchiveToHaikuImage develop tools
     125# Extracts the given archive onto the image under /boot/develop/tools.
     126ExtractArchiveToHaikuImage develop tools
    127127    : /home/bonefish/develop/haiku/misc/gcc-2.95.3-beos-070218/gcc-2.95.3_binutils-2.17_rel-070218.zip ;
    128128
    129129# Add the optional package WonderBrush to the image. The package is downloaded

  • build/jam/OptionalPackages

     
    771771            :
    772772        ;
    773773    }
    774     #UnzipArchiveToHaikuImage home : data/vv.mp3.zip : 0 ;
     774    #ExtractArchiveToHaikuImage home : data/vv.mp3.zip : 0 ;
    775775}
    776776
    777777

  • build/scripts/build_haiku_image

     
    2525# rc
    2626# rmAttrs
    2727# unzip
     28# tar
    2829# vmdkimage
    2930#
    3031if [ $# -gt 0 ]; then
    … …  
    7475fi
    7576
    7677
    77 unzipFile()
     78extractFile()
    7879{
    79     # unzipFile <archive> <directory>
    80     zipFile=$1
    81     targetUnzipDir=$2
     80    # extractFile <archive> <directory>
     81    archiveFile=$1
     82    targetExtractedDir=$2
    8283
    83     echo "Unzipping $zipFile ..."
     84    echo "Extracting $archiveFile ..."
    8485
    85     unzipDir=$tmpDir/unzip
    86     $rmAttrs -rf "$unzipDir"
    87     mkdir -p "$unzipDir"
    88 
    89     $unzip -q -d "$unzipDir" "$zipFile"
    90 
    91     if [ -f $unzipDir/.OptionalPackageDescription ]; then
    92         cat $unzipDir/.OptionalPackageDescription >> $copyrightsFile
     86    extractDir=$tmpDir/extract
     87    $rmAttrs -rf "$extractDir"
     88    mkdir -p "$extractDir"
     89   
     90    case "$archiveFile" in
     91        *.zip)
     92            $unzip -q -d "$extractDir" "$archiveFile"
     93            ;;
     94        *.tgz)
     95            $tar -C "$extractDir" -xf "$archiveFile"
     96            ;;
     97        *)
     98            echo "Unhandled archive extension in build_haiku_image extractFile()"
     99            exit 1
     100            ;;
     101    esac
     102       
     103    if [ -f $extractDir/.OptionalPackageDescription ]; then
     104        cat $extractDir/.OptionalPackageDescription >> $copyrightsFile
    93105        echo >> $copyrightsFile
    94         rm $unzipDir/.OptionalPackageDescription
     106        rm $extractDir/.OptionalPackageDescription
    95107    fi
    96108
    97     $cp -r "${sPrefix}$unzipDir/." "${tPrefix}$targetUnzipDir"
     109    $cp -r "${sPrefix}$extractDir/." "${tPrefix}$targetExtractedDir"
    98110
    99     $rmAttrs -rf "$unzipDir"
     111    $rmAttrs -rf "$extractDir"
    100112}
    101113
    102114

  • build/scripts/build_haiku_cd

     
    1212# rc
    1313# rmAttrs
    1414# unzip
     15# tar
    1516# generate_attribute_stores
    1617#
    1718if [ $# -gt 0 ]; then
    … …  
    3536rm=rm
    3637
    3738
    38 unzipFile()
     39extractFile()
    3940{
    40     # unzipFile <archive> <directory>
    41     zipFile=$1
    42     targetUnzipDir=$2
     41    # extractFile <archive> <directory>
     42    archiveFile=$1
     43    targetExtractDir=$2
    4344
    44     echo "Unzipping $zipFile ..."
     45    echo "Extracting $archiveFile ..."
    4546
    46     unzipDir=$tmpDir/unzip
    47     $rmAttrs -rf "$unzipDir"
    48     mkdir -p "$unzipDir"
     47    extractDir=$tmpDir/extract
     48    $rmAttrs -rf "$extractDir"
     49    mkdir -p "$extractDir"
     50   
     51    case "$archiveFile" in
     52        *.zip)
     53            $unzip -q -d "$extractDir" "$archiveFile"
     54            ;;
     55        *.tgz)
     56            $tar -C "$extractDir" -xf "$archiveFile"
     57            ;;
     58        *)
     59            echo "Unhandled archive extension in build_haiku_image extractFile()"
     60            exit 1
     61            ;;
     62    esac
    4963
    50     $unzip -q -d "$unzipDir" "$zipFile"
    51 
    52     if [ -f $unzipDir/.OptionalPackageDescription ]; then
    53         cat $unzipDir/.OptionalPackageDescription >> $copyrightsFile
     64    if [ -f $extractDir/.OptionalPackageDescription ]; then
     65        cat $extractDir/.OptionalPackageDescription >> $copyrightsFile
    5466        echo >> $copyrightsFile
    55         rm $unzipDir/.OptionalPackageDescription
     67        rm $extractDir/.OptionalPackageDescription
    5668    fi
    5769
    58     $cp -r "$unzipDir/." "${tPrefix}$targetUnzipDir"
     70    $cp -r "$extractDir/." "${tPrefix}$targetExtractDir"
    5971
    60     $rmAttrs -rf "$unzipDir"
     72    $rmAttrs -rf "$extractDir"
    6173}
    6274
    6375