./0000755000000000000000000000000014345143671007721 5ustar rootrootetc/0000755000000000000000000000000014345143671010337 5ustar rootrootetc/profile.d/0000755000000000000000000000000014345143671012221 5ustar rootrootetc/profile.d/32dev.csh0000644000000000000000000000176414345143671013653 0ustar rootroot#!/bin/csh # $Id: 32dev.csh,v 1.2 2014/01/16 09:32:06 eha Exp eha $ # Created by Jim Diamond (Jim.Diamond@acadiau.ca), # Based on 32dev.sh, which is part of # the Slamd64 Linux project (www.slamd64.com), # Copyright (C) 2007 Frederick Emmott # Distributed under the GNU General Public License, version 2, as # published by the Free Software Foundation. setenv PATH "/usr/bin/32:/usr/lib/qt/bin:$PATH" setenv CC "gcc" # This is actually the /usr/bin/32/gcc wrapper setenv CXX "g++" setenv FC "gfortran" # This is actually the /usr/bin/32/gfortran wrapper setenv F77 "gfortran" if ($?LD_LIBRARY_PATH == 1) then setenv LD_LIBRARY_PATH "/lib:/usr/lib:$LD_LIBRARY_PATH" else setenv LD_LIBRARY_PATH "/lib:/usr/lib" endif if ($?PKG_CONFIG_PATH == 1) then setenv PKG_CONFIG_PATH "/usr/lib/pkgconfig:$PKG_CONFIG_PATH" else setenv PKG_CONFIG_PATH "/usr/lib/pkgconfig" endif if (-d /opt/kde3/lib/qt3) setenv QTDIR /opt/kde3/lib/qt3 if (-d /usr/lib/qt) setenv QT4DIR /usr/lib/qt etc/profile.d/32dev.sh0000644000000000000000000000257014345143671013504 0ustar rootroot#!/bin/sh # $Id: 32dev.sh,v 1.4 2014/10/02 09:31:37 eha Exp eha $ # Copyright (C) 2007 Frederick Emmott # Copyright 2009 Eric Hameleers, Eindhoven, NL # Based on the file with the same name which is part of # the Slamd64 Linux project (www.slamd64.com) # Distributed under the GNU General Public License, version 2, as # published by the Free Software Foundation. # Modify the compilation/linking environment: export PATH="/usr/bin/32:/usr/lib/qt/bin:$PATH" export CC="gcc" # This is actually the /usr/bin/32/gcc wrapper export CXX="g++" export FC="gfortran" # This is actually the /usr/bin/32/gfortran wrapper export F77="gfortran" # Change the shell prompt to make it clear that we are in 32bit mode: PS1='\u@\h (32bit):\w\$ ' # Check for Qt5, Qt4 and the old 'compatibility install' of Qt3: if [ -d /opt/kde3/lib/qt3 ]; then export QTDIR=/opt/kde3/lib/qt3 fi if [ -d /usr/lib/qt ]; then export QT4DIR=/usr/lib/qt fi if [ -d /usr/lib/qt5 ]; then export QT5DIR=/usr/lib/qt5 fi if [ ! "$LD_LIBRARY_PATH" = "" ]; then export LD_LIBRARY_PATH="/usr/local/lib:/lib:/usr/lib:$LD_LIBRARY_PATH" else export LD_LIBRARY_PATH="/usr/local/lib:/lib:/usr/lib" fi if [ ! "$PKG_CONFIG_PATH" = "" ]; then export PKG_CONFIG_PATH="/usr/local/lib/pkgconfig:/usr/lib/pkgconfig:$PKG_CONFIG_PATH" else export PKG_CONFIG_PATH="/usr/local/lib/pkgconfig:/usr/lib/pkgconfig" fi install/0000755000000000000000000000000014345143671011232 5ustar rootrootinstall/doinst.sh0000644000000000000000000000075514345143671013075 0ustar rootroot( cd usr/bin/32 ; rm -rf cc ) ( cd usr/bin/32 ; ln -sf gcc cc ) ( cd usr/bin/32 ; rm -rf f77 ) ( cd usr/bin/32 ; ln -sf gfortran f77 ) ( cd usr/bin/32 ; rm -rf f95 ) ( cd usr/bin/32 ; ln -sf gfortran f95 ) ( cd usr/bin/32 ; rm -rf fortran ) ( cd usr/bin/32 ; ln -sf gfortran fortran ) ( cd usr/bin/32 ; rm -rf g++ ) ( cd usr/bin/32 ; ln -sf gcc g++ ) ( cd usr/bin/32 ; rm -rf g77 ) ( cd usr/bin/32 ; ln -sf gfortran g77 ) ( cd usr/bin/32 ; rm -rf g95 ) ( cd usr/bin/32 ; ln -sf gfortran g95 ) install/slack-desc0000644000000000000000000000155314345143671013172 0ustar rootroot# HOW TO EDIT THIS FILE: # The "handy ruler" below makes it easier to edit a package description. Line # up the first '|' above the ':' following the base package name, and the '|' # on the right side marks the last column you can put a character in. You must # make exactly 11 lines for the formatting to be correct. It's also # customary to leave one space after the ':'. |-----handy-ruler------------------------------------------------------| compat32-tools: compat32-tools (32bit compatibility tools for 64bit Slackware) compat32-tools: compat32-tools: The compat32-tools are a series of scripts that allow compat32-tools: the user to add a 32bit compatibility layer (multilib) compat32-tools: to 64bit Slackware. compat32-tools: compat32-tools: compat32-tools: compat32-tools: compat32-tools: Written by Fred Emmott and Eric Hameleers compat32-tools: usr/0000755000000000000000000000000014345143671010375 5ustar rootrootusr/bin/0000755000000000000000000000000014345143671011145 5ustar rootrootusr/bin/32/0000755000000000000000000000000014345143671011371 5ustar rootrootusr/bin/32/gcc0000755000000000000000000000163714345143671012062 0ustar rootroot#!/bin/bash # $Id: gccwrapper,v 1.1 2009/09/14 10:35:12 eha Exp eha $ # Copyright (C) 2007 Frederick Emmott # Copyright 2009 Eric Hameleers, Eindhoven, NL # Based on the file with the same name which is part of # the Slamd64 Linux project (www.slamd64.com) # Distributed under the GNU General Public License, version 2, as # published by the Free Software Foundation. # Find the stub gcc's directory: STUBPATH=$(cd $(dirname $0); pwd) # Now find the "real" gcc REALCC=$(PATH="$(echo $PATH | sed "s#\(.*\):\?$STUBPATH/\?:\?#\1#")" which $(basename $0)) # Filter out -m64 from $@ (this is sometimes added even though we specify -m32) declare -a Arguments for i; do case "$i" in -m64) ;; *) Arguments[${#Arguments[@]}]="$i" ;; esac done # Compiling a 32bit program requires we call gcc with -m32 $REALCC -m32 "${Arguments[@]}" # Exit with $REALCC's exit code exit $? usr/bin/32/gfortran0000755000000000000000000000141614345143671013143 0ustar rootroot#!/bin/bash # $Id: gfortranwrapper,v 1.1 2014/01/16 09:32:24 eha Exp eha $ # Copyright 2014 Eric Hameleers, Eindhoven, NL # Distributed under the GNU General Public License, version 2, as # published by the Free Software Foundation. # Find the stub gfortran's directory: STUBPATH=$(cd $(dirname $0); pwd) # Now find the "real" gfortran REALFC=$(PATH="$(echo $PATH | sed "s#\(.*\):\?$STUBPATH/\?:\?#\1#")" which $(basename $0)) # Filter out -m64 from $@ (this is sometimes added even though we specify -m32) declare -a Arguments for i; do case "$i" in -m64) ;; *) Arguments[${#Arguments[@]}]="$i" ;; esac done # Compiling a 32bit program requires we call gfortran with -m32 $REALFC -m32 "${Arguments[@]}" # Exit with $REALFC's exit code exit $? usr/doc/0000755000000000000000000000000014345143671011142 5ustar rootrootusr/doc/compat32-tools-3.10/0000755000000000000000000000000014345143671014307 5ustar rootrootusr/doc/compat32-tools-3.10/README0000644000000000000000000000543714345143671015200 0ustar rootrootUsing 32-bit Binaries on Slackware64 ------------------------------------ In order to use and compile 32bit software on Slackware64, you will have to replace your gcc and glibc packages with multilib versions, or else install 'compat32' packages for gcc and glibc that add the 32bit binaries for these packages. You can not just take the binaries from a 32bit Slackware. Instead, the 'compat32' versions of the gcc and glibc packages will have to be compiled on the 64bit system. You will also need to install several supporting 32bit libraries. These libraries can be taken from the 32bit Slackware of the same version as your Slackware64. To make things easier for you, this package contains two scripts: convertpkg-compat32 massconvert32.sh The first script converts a single 32bit Slackware package into a 'compat32' package that can be installed on 64bit Slackware. The second script will do the hard work for you: it contains an internal list of Slackware packages that you will need for a functional multilib Slackware64. The script will convert these packages to 'compat32' packages. All that the script needs is a single commandline argument: the path to a local 32bit Slackware package tree (this is the directory below which you find 'a', 'ap', ... 'y' subdirectories). Building 32-bit binaries on Slackware64 --------------------------------------- In order to compile 32bit software when the full set of multilib binaries is installed, all that you need is adding "-m32" to the compiler flags. Quite a few build systems however insist on adding -m64, regardless of what you tell it. For this reason, the package installs a few scripts to enforce 32-bit builds. To load them into your path (including wrappers around gcc) you only need to run the following command in your bash shell: . /etc/profile.d/32dev.sh Note the single dot followed by a space: this is the 'source' command which will set the various variables in your current shell environment. Do not forget to exit from your shell (and login again) after you have finished compiling your 32bit software, to get rid of the 32bit-enforcing environmental variables! Additionally, if you compile any 32bit binaries conflict with 64-bit versions, they should be installed into bin/32/, not bin/. A typical invocation of the 'configure' command as an example: . /etc/profile.d/32dev.sh ./configure \ --prefix=/usr \ --bindir=/usr/bin/32 Keeping your multilib environment up to date -------------------------------------------- The third-party program 'compat32pkg' is able to keep your multilib packages up to date. It works somewhat like what slackpkg does for regular Slackware. See http://compat32pkg.sourceforge.net/ =============================================================================== Eric Hameleers 15-nov-2010 usr/doc/compat32-tools-3.10/compat32-tools.SlackBuild0000644000000000000000000000630514345143671021040 0ustar rootroot#!/bin/sh # Copyright (c) 2009 Frederick Emmott # Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Eric Hameleers, Eindhoven, NL # All rights reserved. # # Redistribution and use of this script, with or without modification, is # permitted provided that the following conditions are met: # # 1. Redistributions of this script must retain the above copyright # notice, this list of conditions and the following disclaimer. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED # WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO # EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. PRGNAM=compat32-tools VERSION=3.10 ARCH=noarch TAG=${TAG:-alien} BUILD=${BUILD:-3} CWD=$(pwd) TMP=${TMP:-/tmp} PKG=$TMP/package-$PRGNAM rm -rf $PKG mkdir -p $TMP $PKG # Add the scripts that change your environment for 32bit compilation # (but do not make it executable by default): mkdir -p $PKG/etc/profile.d install -o root -m644 $CWD/32dev.sh $PKG/etc/profile.d/32dev.sh install -o root -m644 $CWD/32dev.csh $PKG/etc/profile.d/32dev.csh # Add the 'gcc' wrapper script to be used for building 32bit software: mkdir -p $PKG/usr/bin/32 install -o root -m755 $CWD/gccwrapper $PKG/usr/bin/32/gcc # Add the 'gfortran' wrapper script to be used for building 32bit software: mkdir -p $PKG/usr/bin/32 install -o root -m755 $CWD/gfortranwrapper $PKG/usr/bin/32/gfortran # Add symlinks for cc and g++ stubs: ( cd $PKG/usr/bin/32; ln -s gcc g++; ln -s gcc cc; ) # Add symlinks for fortran stubs: ( cd $PKG/usr/bin/32; ln -s gfortran f77; ln -s gfortran f95; ln -s gfortran g77; ln -s gfortran g95; ln -s gfortran fortran; ) # Add the two scripts that will facilitate converting 32bit Slackware # packages to a format that is suitable to be installed on 64bit Slackware. # Since these scripts should be run as root, dump them into a sbin directory: mkdir -p $PKG/usr/sbin install -m755 -o root $CWD/check-compat32 $PKG/usr/sbin/check-compat32 install -m755 -o root $CWD/convertpkg-compat32 $PKG/usr/sbin/convertpkg-compat32 install -m755 -o root $CWD/massconvert32.sh $PKG/usr/sbin/massconvert32.sh # Add documentation: mkdir -p $PKG/usr/doc/$PRGNAM-$VERSION # Much of this README is from the Slamd64 file: # http://slackware.org.uk/slamd64/slamd64-current/slamd64-FAQ/Compiling.txt cat $CWD/README > $PKG/usr/doc/$PRGNAM-$VERSION/README # Add this script: cat $0 > $PKG/usr/doc/$PRGNAM-$VERSION/$PRGNAM.SlackBuild # Add a package description: mkdir -p $PKG/install cat $CWD/slack-desc > $PKG/install/slack-desc # Build the package: cd $PKG /sbin/makepkg -l y -c n $TMP/${PRGNAM}-${VERSION}-${ARCH}-${BUILD}${TAG}.tgz usr/sbin/0000755000000000000000000000000014345143671011330 5ustar rootrootusr/sbin/check-compat320000755000000000000000000000376314345143671013772 0ustar rootroot#!/bin/bash #$Id: check-compat32,v 1.2 2019/12/12 20:49:51 eha Exp eha $ # # Purpose: # To check if any of the installed -compat32 packages is older than # the accompanying 64-bit package. # # Author: # Eric Hameleers # # No verbose output by default: DEBUG=0 showhelp () { cat <> Found '$PKG32'..." PKG64=$(echo ${FULL32} |cut -f5 -d'/' |rev |cut -f5- -d'-' |rev) # Differentiate between eg. 'openssl' and 'openssl-solibs': VER64=$( for PACK in $(find /var/log/packages/ -name "${PKG64}-*" |grep -v -- -compat32) ; do if [ "$(echo $PACK |cut -f5 -d'/' |rev |cut -f4- -d'-' |rev)" = "${PKG64}" ]; then echo $(echo $PACK |cut -f5 -d'/' | rev | cut -f3 -d'-' |rev) ; fi ; done ) # Issue a warning if the version of the 64-bit package differs: if [ -n "$VER64" -a "$VER32" != "$VER64" ]; then echo "** Package '$PKG64' has version '$VER64' but package '$PKG32' has version '$VER32'" fi done [ $DEBUG -ne 0 ] && echo "-- Finished checking installed packages." usr/sbin/convertpkg-compat320000755000000000000000000003436014345143671015074 0ustar rootroot#!/bin/sh # $Id: convertpkg-compat32,v 1.40 2022/12/10 17:51:38 eha Exp eha $ # Copyright (c) 2009 Frederick Emmott # Copyright (c) 2009, 2010, 2011, 2012, 2013 Eric Hameleers, Eindhoven, NL # # Permission to use, copy, modify, and/or distribute this software for any # purpose with or without fee is hereby granted, provided that the above # copyright notice and this permission notice appear in all copies. # # THE SOFTWARE IS PROVIDED ``AS IS'' AND THE AUTHOR DISCLAIMS ALL WARRANTIES # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. # Contributions to the udev cleanup code by phenixia2003. # --------------------------------------------------------------------------- # Convert a 32-bit Slackware package (s390 or x86) # to a compatibility package for a 64bit multilib Slackware. # Catch errors and display the offending line number: set -e trap 'echo "$0 FAILED at line ${LINENO}"' ERR # Package-independent variables ARCH=${ARCH:-$(uname -m)} TAG=${TAG:-compat32} # tag to be used for the converted package OUTPUT=${OUTPUT:-/tmp} # where the package gets created TMP=${TMP:-/tmp} # location for temporary files # $BUILD can also be overridden, though it in-turn is overridden # if an output package name is specified on the command line. # Blacklist of packages not to use this script on (these *have* to be compiled # on a 64bit box): BLACKLIST=" glibc.* kernel.* gcc.* " function show_help () { # Write the help text to output: cat < [-o output_package_file_name] [-d output_directory] [-s custom_slack_desc] [-e custom_package_extension] $(basename $0) is used to convert a 32-bit Slackware package into a '32-bit compatibility' package, for installion on 64-bit Slackware. required parameters:: -i input_package_file_name : 32-bit package to convert optional parameters:: -d destination_directory : create package in this directory -e extension : use another valid extension instead of 'txz' -o output_package_file_name : use custom output package filename -s output_slack_desc : custom slack-desc file to use for new package environment variables: ARCH (target architecture; defaults to \$(uname -m)) BUILD (build number for output package; defaults to same as input package. output_package_file_name overrides this value) TAG (build tag, defaults to ${TAG})) OUTPUT (location to create the package; defaults to ${OUTPUT}) TMP (location for temporary files; defaults to ${TMP}) EOF } # Zero some initial variables: OUTPKG="" PKGEXT="txz" PKGFILE="" PKGPATH="" SLACKDESC="" # Parse the commandline parameters: while [ ! -z "$1" ]; do case $1 in -d|--destdir) OUTPUT="$(cd ${2}; pwd)" # can be overruled in the "-o" argument! shift 2 ;; -e|--extension) PKGEXT="${2}" shift 2 ;; -h|--help) show_help exit 0 ;; -i|--inpkg) PKGFILE="$(basename ${2})" PKGPATH="$(cd $(dirname ${2}); pwd)/$(basename ${2})" shift 2 ;; -o|--outpkg) OUTPKG="$(basename ${2})" # Check if the user added a directory component. If yes, it will override # whatever was supplied with the "-d" argument!: if [ "$OUTPKG" != "${2}" ]; then OUTPUT="$(cd $(dirname ${2}); pwd)" fi shift 2 ;; -s|--slack-desc) SLACKDESC="$(cd $(dirname ${2}); pwd)/$(basename ${2})" shift 2 ;; -*) echo "Unsupported parameter '$1'!" exit 1 ;; *) # Do nothing shift ;; esac done # Bail out now if we did not get an input package: if [ -z "$PKGFILE" -o ! -e "$PKGPATH" ]; then echo "** Please supply a valid input package! **" show_help exit 3 fi # if a destination_directory was specified, abort now if we can not create it: if [ -n "$OUTPUT" -a ! -d "$OUTPUT" ]; then echo "Creating output directory '$OUTPUT'..." mkdir -p $OUTPUT if [ ! -w "$OUTPUT" ]; then echo "Creating output directory '$OUTPUT' failed!" exit 3 fi fi # Figure out initial variables PKGNAM=$(echo $PKGFILE | rev | cut -f4- -d- | rev) VERSION=$(echo $PKGFILE | rev | cut -f3 -d- | rev) BUILD=${BUILD:-$(echo $PKGFILE | rev | cut -f1 -d- | cut -f2- -d. | rev)} OUTPKG=${OUTPKG:-"${PKGNAM}-compat32-${VERSION}-${ARCH}-${BUILD}${TAG}.${PKGEXT}"} # With OUTPKG as commandline param, it may not just be "${PKGNAM}-compat32": PKGNAM32=$(echo $OUTPKG | rev | cut -f4- -d- | rev) for regex in $BLACKLIST; do if echo $PKGNAM | grep -Pq "$regex"; then echo "Package $PKGNAM is blacklisted by '$regex', aborting." exit 2 fi done echo "Converting package $PKGNAM (version $VERSION) to $OUTPKG ($PKGNAM32)" PKG=$TMP/package-$PKGNAM32 rm -rf $PKG mkdir -p $PKG $TMP cd $PKG || exit 1 # Explode the package into $PKG . # We will need to slightly modify an existing install/doinst.sh # It should still create symlinks and run other errands when the resulting # package is installed, but should not mess with the files we are going to # remove for the -compat32 package. /sbin/explodepkg $PKGPATH # Check if the user fed us a 64bit package: if [ -d usr/lib64 -o -d lib64 ]; then echo "** This script converts 32bit packages for Slackware64 multilib!" echo "** It looks like you gave me a 64bit package instead." echo "** Are you certain you want to convert the package $(basename $PKGPATH) ?" echo "** Press [Ctrl]-[C] now if you want to abort the script." read JUNK fi # # Take special care of the following packages when stripping things: # elogind, eudev, gdk-pixbuf2, gtk+2, gtk+3, mesa, pango, polkit, samba, udev # and: # e2fsprogs, libgphoto2, libinput, libwacom, pipewire, pulseaudio, sane, v4l-utils # # Stuff we need to keep, we move into KDEP/ and move it back later: mkdir KEEP case "$PKGNAM" in "mesa") cp -a --parents usr/share/vulkan/icd.d KEEP/ ;; "libunwind") cp -a --parents usr/include/libunwind-x86.h KEEP/ ;; esac # Remove stuff we only want from the 64-bit package: if [ "$PKGNAM" = "gtk+2" -o "$PKGNAM" = "gtk+3" -o "$PKGNAM" = "gdk-pixbuf2" -o "$PKGNAM" = "pango" ]; then rm -rf bin sbin usr/{include,sbin,share,info,man,libexec} else rm -rf etc bin sbin usr/{include,sbin,share,info,man,libexec} fi # Take care of 32bit binaries: if [ "$PKGNAM" = "gtk+2" -o "$PKGNAM" = "gtk+3" -o "$PKGNAM" = "gdk-pixbuf2" -o "$PKGNAM" = "pango" ]; then find usr/bin -type f ! -name "*-32" -exec mv {} {}-32 \; elif [ "$PKGNAM" = "llvm" ]; then mkdir -p usr/bin/32 for BIN in $(find usr/bin/ -maxdepth 1 -type f) ; do ln -s ../$(basename $BIN)-32 usr/bin/32/$(basename $BIN) done find usr/bin -maxdepth 1 -type f ! -name "*-32" -exec mv {} {}-32 \; elif [ -d usr/bin ]; then mkdir ./32 find usr/bin -type f -exec mv {} ./32 \; rm -rf usr/bin/* mv ./32 usr/bin/ fi # These are part of the 64-bit package: if [ "$PKGNAM" = "udev" -o "$PKGNAM" = "eudev" -o "$PKGNAM" = "elogind" ]; then rm -rf lib/firmware rm -rf lib/modprobe.d rm -rf lib/udev rm -rf run # Only in Slackware 13.37: rm -rf usr/lib/ConsoleKit elif [ "$PKGNAM" = "polkit" ]; then rm -rf usr/lib/polkit-1 elif [ "$PKGNAM" = "e2fsprogs" -o "$PKGNAM" = "libgphoto2" -o "$PKGNAM" = "libinput" -o "$PKGNAM" = "libwacom" -o "$PKGNAM" = "pipewire" -o "$PKGNAM" = "pulseaudio" -o "$PKGNAM" = "sane" -o "$PKGNAM" = "v4l-utils" ]; then rm -rf lib/udev fi # Strip doinst.sh from everything we can't use: if [ "$PKGNAM" = "gtk+2" -o "$PKGNAM" = "gtk+3" -o "$PKGNAM" = "gdk-pixbuf2" -o "$PKGNAM" = "pango" ]; then # Get rid of symlinks in bin and doc directory: cat install/doinst.sh | grep -v '( cd usr/bin' | grep -v '( cd usr/doc' \ > install/doinst.sh.2 cat install/doinst.sh.2 > install/doinst.sh rm -f install/doinst.sh.2 if [ "$PKGNAM" = "gtk+2" ]; then # Deal with the .new file in gtk+2 that does not get processed: echo "config etc/gtk-2.0/im-multipress.conf.new" \ >> install/doinst.sh fi elif [ "$PKGNAM" = "udev" -o "$PKGNAM" = "eudev" ]; then # Get rid of symlinks in sbin and lib directory, and all the other # non-symlinking stuff: cat install/doinst.sh \ | grep '( cd ' \ | grep -v '( cd sbin' | grep -v '( cd lib/udev' \ | grep -v '( cd usr/lib/ConsoleKit/run-seat.d' \ > install/doinst.sh.2 cat install/doinst.sh.2 > install/doinst.sh rm -f install/doinst.sh.2 elif [ "$PKGNAM" = "aaa_libraries" -o "$PKGNAM" = "openldap" -o "$PKGNAM" = "polkit" ]; then # Remove the doinst.sh completely: rm -f install/doinst.sh elif [ -f install/doinst.sh ]; then # Check for a 'config()' section: if grep -q 'config()' install/doinst.sh ; then cat <<-"EOT" > install/doinst.sh.1 config() { NEW="$1" OLD="$(dirname $NEW)/$(basename $NEW .new)" # If there's no config file by that name, mv it over: if [ ! -r $OLD ]; then mv $NEW $OLD elif [ "$(cat $OLD | md5sum)" = "$(cat $NEW | md5sum)" ]; then # toss the redundant copy rm $NEW fi # Otherwise, we leave the .new copy for the admin to consider... } preserve_perms() { NEW="$1" OLD="$(dirname ${NEW})/$(basename ${NEW} .new)" if [ -e ${OLD} ]; then cp -a ${OLD} ${NEW}.incoming cat ${NEW} > ${NEW}.incoming mv ${NEW}.incoming ${NEW} fi config ${NEW} } EOT else echo -n "" > install/doinst.sh.1 fi # Only keep lines that deal with symlinks in bin/32 and lib directories, # and the config/preserve_perms commands that apply outside of /etc/: ( cat install/doinst.sh \ |grep -v "etc/ld.so.conf" |grep -v "../sbin/" \ |grep -Ev '(config etc|preserve_perms etc)' \ |grep -E '(usr/bin |lib |lib/|^config |^preserve_perms )' > install/doinst.sh.2 cat install/doinst.sh.1 install/doinst.sh.2 \ |sed -e 's# usr/bin# usr/bin/32#g' \ |sed -e 's#32 ; ln -sf ../#&../#' > install/doinst.sh rm -f install/doinst.sh.1 install/doinst.sh.2 ) || true fi # Post-cleanup-cleanup to catch sscript errors: if [ "$PKGNAM" = "samba" ]; then # Get rid of a useless (because taken care of in 64bit package) block: cat install/doinst.sh \ | grep -v 'samba/private' \ > install/doinst.sh.2 cat install/doinst.sh.2 > install/doinst.sh rm -f install/doinst.sh.2 fi # The cxxlibs need some extra consideration because the libraries in # /usr/i486-slackware-linux/lib will not be found by Slackware64. # Note that as of Slackware 14, "usr/i486-slackware-linux" is gone: if [ "$PKGNAM" = "cxxlibs" ]; then if [ -e usr/i486-slackware-linux ] ; then mkdir -p usr/lib # just in case for OLIB in $(find usr/i486-slackware-linux/lib -type f -maxdepth 1) ; do cp -a $OLIB usr/lib/ done cat install/doinst.sh | grep '/i486-slackware-linux' > install/doinst.sh.2 cat install/doinst.sh.2 | sed -e 's#/i486-slackware-linux##g' >> install/doinst.sh rm -f install/doinst.sh.2 fi fi # The qt package installs several symlinks to /usr/bin which point to # binaries in qt's lib directory. We have to strip those from the -compat32 # package. If you want to build 32bit software that needs these qt binaries, # you will have to add /usr/lib/qt/bin/ to your $PATH # We will remove a lot of stuff which we do not need in the compat32 package # if [ "$PKGNAM" = "qt" -o "$PKGNAM" = "qt3" -o "$PKGNAM" = "qt5" ]; then if [ -d usr/lib/qt ] ; then for ITEM in q3porting.xml demos doc examples ; do if [ -e "usr/lib/qt/$ITEM" ] ; then rm -rf "usr/lib/qt/$ITEM" fi done elif [ -d usr/lib/qt5 ] ; then for ITEM in demos doc examples ; do if [ -e "usr/lib/qt5/$ITEM" ] ; then rm -rf "usr/lib/qt5/$ITEM" fi done fi cat install/doinst.sh | grep -v 'usr/bin' | grep -v 'opt/kde3/bin' \ > install/doinst.sh.2 cat install/doinst.sh.2 > install/doinst.sh rm -f install/doinst.sh.2 fi # Move everything we saved to KEEP/ back into the package: if [ $(find KEEP/ | wc -l) -gt 1 ]; then rsync -a KEEP/ ./ fi rm -rf KEEP # Keep documentation we might be required to keep, or is just polite: if [ -d usr/doc ]; then find usr/doc -type f ! -iname "Copyright*" -a ! -iname "COPYING*" -a ! -iname "AUTHORS*" -a ! -iname "LICENSE*" -a ! -iname "GPL*" -a ! -iname "LGPL*" -a ! -iname "THANKS*" | xargs -d '\n' rm -f find usr/doc -type d -depth | xargs -d '\n' rmdir --ignore-fail-on-non-empty fi # Handle the slack-desc file: if [ ! -z $SLACKDESC ]; then echo "Using externally provided slack-desc ($SLACKDESC)..." cat $SLACKDESC > install/slack-desc else if [ ! -f install/slack-desc ]; then # Non-standard package, missing slack-desc, so we use a template: mkdir -p install cat < install/slack-desc # HOW TO EDIT THIS FILE: # The "handy ruler" below makes it easier to edit a package description. Line # up the first '|' above the ':' following the base package name, and the '|' # on the right side marks the last column you can put a character in. You must # make exactly 11 lines for the formatting to be correct. It's also # customary to leave one space after the ':'. |-----handy-ruler------------------------------------------------------| $PKGNAM: $PKGNAM $PKGNAM: $PKGNAM: $PKGNAM: $PKGNAM: $PKGNAM: $PKGNAM: $PKGNAM: $PKGNAM: $PKGNAM: $PKGNAM: EOT fi # Now, re-work the slack-desc: # Fix the handy ruler: SPCS=""; while [ ${#SPCS} -lt ${#PKGNAM32} ]; do SPCS=" $SPCS";done sed -i -r "s/^ *\|-/${SPCS}\|-/" install/slack-desc # Every line; foo: -> foo-compat32: sed -i "s,$PKGNAM:,$PKGNAM32:," install/slack-desc # First line: foo-compat32: foo (description of foo) # -> foo-compat32: foo-compat32 (description of foo) sed -i "s,$PKGNAM32: $PKGNAM ,$PKGNAM32: $PKGNAM32 ," install/slack-desc # Last line: if empty, add 32-bit message sed -i "\$s,^${PKGNAM32}: *$,${PKGNAM32}: This package contains 32-bit compatibility binaries.," install/slack-desc fi # If we ended up with an empty doinst.sh we should remove it now: if [ ! -s install/doinst.sh ]; then rm -f install/doinst.sh fi # Make the package (don't process the symlinks): /sbin/makepkg --linkadd n --chown n $OUTPUT/$OUTPKG echo "Package created: $OUTPUT/$OUTPKG" usr/sbin/massconvert32.sh0000755000000000000000000003610014345143671014400 0ustar rootroot#!/bin/bash # $Id: massconvert32.sh,v 1.113 2022/02/21 13:33:25 eha Exp eha $ # # Written 2009, 2010, 2011, 2012, 2013 Eric Hameleers, Eindhoven, NL # # Convert 32bit slackware packages 'en masse' into compatibility packages # to be installed on slackware64 - providing the 32bit part of multilib. # The string "-compat32" is added at the end of package name when a # compatibility package gets created. This allows it to be installed # on slackware64 alongside the native 64bit versions. # For example: the original 32bit package "bzip2" will be converted to a new # package with the name "bzip2-compat32" # # You also have to install multilib versions of glibc and gcc ! # Before we start [ -x /bin/id ] && CMD_ID="/bin/id" || CMD_ID="/usr/bin/id" if [ "$($CMD_ID -u)" != "0" ]; then echo "You need to be root to run $(basename $0)." exit 1 fi # Should we be verbose? VERBOSE=${VERBOSE:-1} # Do we really convert the packages or only pretend to? DRYRUN=0 # In case we need temporary storage: TMP=${TMP:-/tmp} mkdir -p $TMP if [ ! -w "$TMP" ]; then echo "Can not write to temporary directory '$TMP'!" exit 3 fi # Zero some other variables: SLACK32ROOT="" SLACK32URL="" TARGET64ROOT="" # Helpful instructions in case the user asks for it: function show_help () { # Write the help text to output: cat < [-d output_directory] $(basename $0) converts an essential subset of 32-bit Slackware packages into 'compatibility' packages for 64-bit Slackware. Required parameter - one of these two:: -i 32bit_package_tree A 32bit Slackware package-tree. It should have the a,ap,d,..,y directories immediately below. -u 32bit_package_url The URL of a http or ftp server containing 32bit Slackware packages. It should have the a,ap,d,..,y directories immediately below. Optional parameter:: -d destination_directory create packages in this directory. By default, the new packages will be created in your current directory. -n Dry-run (do not convert packages, just mention their names). -q Only print output if packages are actually being converted (useful for cron jobs). Example of a useable Slackware URL: http://slackware.mirrors.tds.net/pub/slackware/slackware-14.0/slackware EOF } # Parse the commandline parameters: while [ ! -z "$1" ]; do case $1 in -d|--destdir) TARGET64ROOT="$(cd $(dirname "${2}"); pwd)/$(basename "${2}")" shift 2 ;; -h|--help) show_help exit 0 ;; -i|--inputdir) SLACK32ROOT="$(cd $(dirname "${2}"); pwd)/$(basename "${2}")" shift 2 ;; -n|--dry-run) DRYRUN=1 shift ;; -q|--quiet) VERBOSE=0 shift ;; -u|--inputurl) SLACK32URL="${2}" shift 2 ;; -*) echo "Unsupported parameter '$1'!" exit 1 ;; *) # Do nothing shift ;; esac done # A function to determine if there are spaces in the pathname: function contains_spaces () { local CHOPPED=$(echo "$1" | tr -d ' ') [ "x$CHOPPED" = "x$1" ] && return 1 || return 0 } # A function to get a package's URL in the repository: function get_url_pkg () { local BP="$(basename $1)" local PS="$(dirname $1)" local DURL="$2" for FP in $(lftp -c 'open '${DURL}' ; cls -1 '${PS}/${BP}'-*.t?z' 2>/dev/null) ZALIEN ; do if [ "$(echo "$FP"|rev|cut -d- -f4-|cut -d/ -f1| rev)" = "$BP" ]; then break fi done [ "$FP" != "ZALIEN" ] && echo "$DURL/$FP" || echo "" } # A function to retrieve the fullname of a package: function get_pkgfullpath () { local IP="$1" local BP="$(basename $1)" local FP="" for FP in $(ls ${IP}-*.t?z 2>/dev/null) ZALIEN; do if [ "$(echo "$FP"|rev|cut -d- -f4-|cut -d/ -f1| rev)" = "$BP" ]; then break fi done [ "$FP" != "ZALIEN" ] && echo "$FP" || echo "" } # A function to convert a package, # downloading it first if needed, and taking patches into account: function conv_pkg () { local BP="$1" local SERIES="$2" local PATCHLIST="$3" PKGPATH="$SERIES/$BP" REPOFOUND="" # First find out if the requested package exists in the repository: # Two repo location options: URL or local directory. if [ -n "$SLACK32URL" ]; then FULLURL=$(get_url_pkg $PKGPATH $SLACK32URL) if [ -n "$FULLURL" ]; then FULLPKG=$SLACK32ROOT/$SERIES/$(basename $FULLURL) REPOVERSION=$(basename $FULLURL |rev |cut -d- -f3 |rev) REPOBLD="$(basename $FULLURL |rev |cut -d- -f1 |cut -d. -f2- |rev)" else # Package could not be found on the remote server: FULLPKG="" REPOVERSION="" REPOBLD="" fi else FULLPKG=$(get_pkgfullpath $SLACK32ROOT/$PKGPATH) if [ -n "$FULLPKG" ]; then REPOVERSION="$(basename $FULLPKG |rev |cut -d- -f3 |rev)" REPOBLD="$(basename $FULLPKG |rev |cut -d- -f1 |cut -d. -f2- |rev)" else REPOVERSION="" REPOBLD="" fi fi if [ -n "$FULLPKG" ]; then # The requested original was found in the repository. REPOFOUND="yes" # Does the package we want have a patch available? echo "$PATCHLIST" | tr - _ | grep -wq $(echo $BP |tr - _) if [ $? -eq 0 ]; then [ $VERBOSE -eq 1 ] && echo "--- Using Slackware's patch package for $BP" PKGPATH="../patches/packages/$BP" if [ -n "$SLACK32URL" ]; then FULLURL=$(get_url_pkg $PKGPATH "$(dirname $SLACK32URL)/patches") if [ -n "$FULLURL" ]; then FULLPKG=$SLACK32ROOT/$SERIES/$(basename $FULLURL) REPOVERSION=$(basename $FULLURL |rev |cut -d- -f3 |rev) REPOBLD="$(basename $FULLURL |rev |cut -d- -f1 |cut -d. -f2- |rev)" else FULLPKG="" REPOVERSION="" REPOBLD="" fi else FULLPKG=$(get_pkgfullpath $SLACK32ROOT/$PKGPATH) if [ -n "$FULLPKG" ]; then REPOVERSION="$(basename $FULLPKG |rev |cut -d- -f3 |rev)" REPOBLD="$(basename $FULLPKG |rev |cut -d- -f1 |cut -d. -f2- |rev)" else REPOVERSION="" REPOBLD="" fi fi fi fi if [ -z "$FULLPKG" ]; then if [ -n "$REPOFOUND" ]; then [ $VERBOSE -eq 1 ] && echo "*** FAIL: patch-package for '$BP' was not found in repository (original package present, this means a repository mismatch)!" else [ $VERBOSE -eq 1 ] && echo "*** FAIL: package '$BP' was not found in repository!" fi return fi # Package (or patch) available - let's start! # Do we have a local converted package already? HAVE_COMPAT32="$(get_pkgfullpath $TARGET64ROOT/${SERIES}-compat32/$BP-compat32)" if [ -n "$HAVE_COMPAT32" ]; then COMPAT32VERSION="$(echo "$HAVE_COMPAT32" |rev|cut -d- -f3|rev)" COMPAT32BLD="$(echo "$HAVE_COMPAT32" |rev|cut -d- -f1|cut -d. -f2-|rev)" if [ "$COMPAT32VERSION" = "$REPOVERSION" -a "${COMPAT32BLD%compat32}" = "$REPOBLD" ] then [ $VERBOSE -eq 1 ] && echo "--- ${BP}-compat32 version '$COMPAT32VERSION' already available" else if [ $DRYRUN -eq 0 ]; then echo ">>> Deleting old version '$COMPAT32VERSION' of '${BP}-compat32'" else echo "${BP}: existing package needs update" fi FILE_TO_REMOVE=$HAVE_COMPAT32 HAVE_COMPAT32="" fi else if [ $DRYRUN -eq 1 ]; then echo "${BP}: new package will be converted" fi fi # If we do not have the latest -compat32 package, then run the conversion: if [ ! -n "$HAVE_COMPAT32" -a $DRYRUN -eq 0 ]; then if [ -n "$SLACK32URL" ]; then # Download the Slackware package before converting it: ( mkdir -p $SLACK32ROOT/$SERIES cd $SLACK32ROOT/$SERIES lftp -c "open $(dirname $FULLURL) ; get $(basename $FULLURL)" 2>/dev/null ) fi [ $VERBOSE -eq 1 ] && echo "--- $BP" # Convert the Slackware package into a -compat32 version: sh $CONV32 -i $FULLPKG -d $TARGET64ROOT/${SERIES}-compat32 if [ -n "$FILE_TO_REMOVE" ]; then # This is where we delete an older version of the -compat32 package: rm $(echo $FILE_TO_REMOVE | rev | cut -d. -f2- | rev).* FILE_TO_REMOVE="" fi fi } # Safety checks in case a URL was provided: if [ -n "$SLACK32URL" ]; then if [ -n "$SLACK32ROOT" ]; then echo "*** Options '-i' and '-u' can not be used together!" exit 1 else # Define a 'temporary' root directory where we will download packages: SLACK32ROOT="${TMP}/alienBOB/slackware" if ! which lftp 1>/dev/null 2>&1 ; then echo "No lftp binary detected! Need lftp for package downloading!" exit 1 fi fi fi # The root directory of 32bit Slackware packages # (should have the a,ap,d,..,y directories immediately below): # Let's use a fallback directory in case none was specified: SLACK32ROOT="${SLACK32ROOT:-"/home/ftp/pub/Linux/Slackware/slackware-current/slackware"}" # The output directory for our converted packages; defaults to the current dir. # Note that {a,ap,d,l,n,x}-compat32 directories will be created below this # directory if they do not yet exist: TARGET64ROOT="${TARGET64ROOT:-"$(pwd)"}" # Abort if we got directories with spaces in them: if contains_spaces "$SLACK32ROOT" ; then echo "Directories with spaces are unsupported: '$SLACK32ROOT'!" exit 1 fi if contains_spaces "$TARGET64ROOT" ; then echo "Directories with spaces are unsupported: '$TARGET64ROOT'!" exit 1 fi # Where the scripts are: SRCDIR=$(cd $(dirname $(which $0)); pwd) # The script that does the package conversion: CONV32=$SRCDIR/convertpkg-compat32 # Bail out if the conversion script is not available/working: if [ ! -f $CONV32 ]; then echo "Required script '$CONV32' is not present or not executable! Aborting..." exit 1 fi # We can not proceed if there are no packages and we did not get an URL: if [ -z "$SLACK32URL" ]; then if [ ! -d $SLACK32ROOT/a -o ! -d $SLACK32ROOT/ap -o ! -d $SLACK32ROOT/d -o ! -d $SLACK32ROOT/l -o ! -d $SLACK32ROOT/n -o ! -d $SLACK32ROOT/x -o ! -d $SLACK32ROOT/xap ]; then echo "Required package directories a,ap,d,l,n,x,xap below '$SLACK32ROOT' are not found! Aborting..." exit 1 fi fi # If a destination_directory was specified, abort now if we can not create it: if [ -n "$TARGET64ROOT" -a ! -d "$TARGET64ROOT" ]; then echo "Creating output directory '$TARGET64ROOT'..." mkdir -p $TARGET64ROOT if [ ! -w "$TARGET64ROOT" ]; then echo "Creation of output directory '$TARGET64ROOT' failed!" exit 3 fi fi # Get a list of available patches if [ -n "$SLACK32URL" ]; then PATCH_LIST=$(echo $(lftp -c "open $(dirname $SLACK32URL)/patches/packages/ ; cls *.t?z" 2>/dev/null | rev | cut -f4- -d- |rev)) else PATCH_LIST=$(echo $(cd $(dirname $SLACK32ROOT)/patches/packages/ 2>/dev/null ; ls -1 *.t?z 2>/dev/null | rev | cut -f4- -d- |rev)) fi # This is the script's internal list of what I consider as the essential # 32bit multilib package set for your Slackware64: # The A/ series: A_COMPAT32=" aaa_elflibs aaa_libraries attr bzip2 cracklib cups cxxlibs dbus e2fsprogs elogind eudev libgudev libpwquality lzlib openssl-solibs openssl10-solibs pam plzip udev util-linux xz " # The AP/ series: AP_COMPAT32=" cdparanoia cups cups-filters flac lm_sensors mariadb mpg123 mysql sqlite " # The D/ series: D_COMPAT32=" libtool llvm opencl-headers " # The L/ series: L_COMPAT32=" Mako SDL2 SDL2_gfx SDL2_image SDL2_mixer SDL2_net SDL2_ttf aalib alsa-lib alsa-oss alsa-plugins atk at-spi2-atk at-spi2-core audiofile brotli cairo dbus-glib elfutils esound expat ffmpeg fftw fluidsynth freetype fribidi gamin gc gdk-pixbuf2 gdk-pixbuf2-xlib giflib glib2 gmp gnome-keyring gobject-introspection graphene graphite2 gtk+2 gtk+3 gst-plugins-bad-free gst-plugins-base gst-plugins-base0 gst-plugins-good gst-plugins-good0 gst-plugins-libav gstreamer gstreamer0 hal harfbuzz icu4c isl jansson jasper json-c json-glib keyutils lame lcms lcms2 libaio libarchive libart_lgpl libasyncns libbluray libcaca libcap libcdio libcdio-paranoia libclc libcroco libdbusmenu libdvdnav libedit libelf libexif libffi libglade libgnt libgphoto2 libidn libidn2 libieee1284 libjpeg libjpeg-turbo libmad libmng libmpc libnice libnl3 libnsl libnotify libnss_nis libogg libpcap libpng librsvg libsamplerate libsigc++3 libsndfile libssh libtasn1 libtermcap libtheora libtiff libunistring libunwind liburing libusb libvorbis libvpx libwebp libxkbcommon libxml2 libxslt lmdb lz4 lzo mozilla-nss ncurses ocl-icd openal-soft openexr openjpeg opus orc pango pcre pcre2 pipewire polkit popt pulseaudio python-six qt qt5 readline rpcsvc-proto sbc sdl slang speex speexdsp startup-notification svgalib taglib talloc tdb tevent v4l-utils vid.stab wavpack woff2 xxHash zlib zstd " # The N/ series: N_COMPAT32=" c-ares curl cyrus-sasl gnutls krb5 libgcrypt libgpg-error libtirpc nettle openldap-client openldap openssl p11-kit samba " # The X/ series: X_COMPAT32=" egl-wayland eglexternalplatform fontconfig freeglut glew glu intel-vaapi-driver libFS libICE libSM libX11 libXScrnSaver libXTrap libXau libXaw libXcomposite libXcursor libXdamage libXdmcp libXevie libXext libXfixes libXfont libXfont2 libXfontcache libXft libXi libXinerama libXmu libXp libXpm libXprintUtil libXrandr libXrender libXres libXt libXtst libXv libXvMC libXxf86dga libXxf86misc libXxf86vm libdmx libdrm libepoxy libfontenc libglvnd libinput libpciaccess libpthread-stubs libva libva-intel-driver libvdpau libwacom libxcb libxshmfence mesa pixman vulkan-sdk wayland xcb-util xorgproto " # The XAP/ series: XAP_COMPAT32=" sane " # Create target directories if they do not exist: for TDIR in a-compat32 ap-compat32 d-compat32 l-compat32 n-compat32 x-compat32 xap-compat32 ; do mkdir -p $TARGET64ROOT/$TDIR if [ ! -w $TARGET64ROOT/$TDIR ]; then echo "Directory '$TARGET64ROOT/$TDIR' is not writable! Aborting..." exit 1 fi done # Convert the 32bit packages from A AP D L N and X series, checking for patches: [ $VERBOSE -eq 1 ] && echo "*** Starting the conversion process:" [ $VERBOSE -eq 1 ] && echo "*** 'A' series:" for INPKG in $A_COMPAT32 ; do conv_pkg $INPKG a "$PATCH_LIST" done [ $VERBOSE -eq 1 ] && echo "*** 'AP' series:" for INPKG in $AP_COMPAT32 ; do conv_pkg $INPKG ap "$PATCH_LIST" done [ $VERBOSE -eq 1 ] && echo "*** 'D' series:" for INPKG in $D_COMPAT32 ; do conv_pkg $INPKG d "$PATCH_LIST" done [ $VERBOSE -eq 1 ] && echo "*** 'L' series:" for INPKG in $L_COMPAT32 ; do conv_pkg $INPKG l "$PATCH_LIST" done [ $VERBOSE -eq 1 ] && echo "*** 'N' series:" for INPKG in $N_COMPAT32 ; do conv_pkg $INPKG n "$PATCH_LIST" done [ $VERBOSE -eq 1 ] && echo "*** 'X' series:" for INPKG in $X_COMPAT32 ; do conv_pkg $INPKG x "$PATCH_LIST" done [ $VERBOSE -eq 1 ] && echo "*** 'XAP' series:" for INPKG in $XAP_COMPAT32 ; do conv_pkg $INPKG xap "$PATCH_LIST" done # Mention downloaded packages if we used a URL as source: if [ $VERBOSE -eq 1 -a $DRYRUN -eq 0 -a -n "$SLACK32URL" ]; then echo "WARNING: packages which were downloaded from '$SLACK32URL'" echo "have been left in directory '$SLACK32ROOT'." echo "It is safe to remove these now." echo "" fi [ $VERBOSE -eq 1 ] && echo "*** Conversion done!"