#! /bin/bash
#
#    Wo etwas zu ersetzen ist: mit %%% gekennzeichnet
#
### * 1) Einzugebende Definitionen  (bleiben meist unverändert)
#
DISTRO="mn"                                     
DISTRONOTE="Paket von W.Landgraf   :) MONKEYNET Linux    www.monkey.is-a-geek.net/tgz"
#                                                   Pakete kompatibel mit Slackware current
#
#
# NOTMAKE=0: Normalfall: Programm /TBZ2DIR/ $NAME-$VERSION.tar.bz2  oder .gz ; 
#            ausführen: ./configure, #make, #make install, #make clean 
# NOTMAKE!=0: manuell übersetzter Code ohne clean schon/noch in $SOURCEDIR vhd ist und nur gepackt wd soll,  : 
#    kein Entpacken; kein Löschen des Ordners der Übersetzung, kein #make
#   NOTMAKE=1:  wie bei =0, starten von aussen, kein config/make, nur install
#   NOTMAKE=2: aktuelles dir packen, falls angegeben, nach Paket $NAME-$VERSION-...   
#     Aber nicht nötig Name, Version (wird 'pwd' genommen), *** einfachstes Packen eines Programmes was schon erfolgreich
#     manuell übersetzt / installiert wurde, und im selben Ordner nur gepackt werden soll, alle Namen werden an die des
#     Ordners angepast, fehlende Dateien ersetzt
# *** Bei jeder manuellen Installierung von Programmen kann also nach dem #make install und vor dem #make clean 
#     vorliegendes skript in den aktuellen Ordner kopiert und ausgeführt werden, wobei   NAME, VERSION, ZUSATZ leer bleiben
#     und Fehlendes halbwegs sinnvoll automatisch ersetzt wird , NOTMAKE=2 setzen    :)  
# *** Das Kernel-Paket startet man dagegen am besten vom download-Ordner aus und füllt unten die genaue Version, patch aus;
#     im download-Ordner sollten ausser linux ... .tar.bz2 auch patch ... .bz2, linux ... .SlackBuild und linux ... .slack-desc
#     sein und wenigenstens ungefähr die Versions-Angabe enthalten sowie keine älteren Versionen mehr vhd sein
#   Das zu bauende Programm muß als <name-version>.tar.bz2  oder .tar.gz  im Ordner $TBZ2DIR  (=/downloads/Programs  normalerweise) sein,
#     dazu eine Beschreibung in  <>.slack-desc   und  vorliegende Datei entsprechend benannt und angepaßt  <>.SlackBuild.
#   Beim Kernel zusätzlich noch  config-<version>   (darin lokale_version geändert falls nicht -1mn) 
#     Falls ein patch vorhanden und anzuwenden, ferner noch   patch-<version-patch> ;  in diesem Fall m 
#     am Anfang sind dann Fragen zur Konfiguration des Kernels zu beantworten.
#     Die den Bau von Kernel-Paketen betreffenden Punkte sind mit #### gezeichnet und so schnell auffindbar/aktivier- bzw desaktivierbar;
#     zur Vermeidung verschiedener SlackBuild-Skripte und Fallunterscheidungen betrifft das nur unbedingt nötige Änderungen,
#     Fehlermeldungen wegen sonstigen  Nebensächlichkeiten ignorieren. 
#   Kernel-Paket enthält:  /boot/ vmlinuz , config , System.map (<- #nm vmlinuz) :  Kernel, Konfiguration, Symboltabelle ;
#     /lib/modules:   Kernel-Module, diejenigen Teile des Kernels, die nicht in vmlinuz enthalten sind, bei Bedarf mit
#     #modprobe einzeln ladbar ;  /usr/src/$NAMETGZ  Quellprogramm des Kernels ;  davon sind die Headers in
#     /usr/src/$NAMETGZ/include  die Verbindungen der Kernel-Funktionen nach ausen, durch Programme aufrufbar.
#     Davon sind nur diejenigen nutzbar, die in der verwendeten Version von glibc und vom Kernel vorhanden waren als glibc
#     übersetzt wurde -- diese sind in /usr/include enthalten, und insbesondere nur falls/dann bzw. unmittelbar bevor durch
#     die aktuellen des Kernels in /usr/src/$NAMETGZ/include zu ersetzen wenn/womit glibc neu übersetzt wird      
#   Achtung:  Der Paketname wird definitiv aus nachfolgenden Angaben zu NAMETGZ=$NAME-$VERSION$ZUSATZ-$ARCH-$BUILD gebildet;
#     alle Dateien $NAME-$VERSION*.tgz oder .bz2 werden dazu zusammengesetzt und verwendet, ebenso egal der Name des darin
#     enthaltenen Ordners  !!!
#   Nach Installierung der hier gebauten Pakete des Kernels nötig:
#     * /etc/rc.d/rc.modules.new überprüfen, in ./rc.modules umwandeln ;  * #rdev /boot/vmlinuz* /dev/hda1 ; 
#     * ggf. initrd bilden:  #mkinitrd -c -k 2.6.22-rc7-git8-1mn -m jbd2:ext4dev:ext2:ext3:minix:reiserfs -r /dev/hda1 -f ext4dev  ;
#     * Eintrag in  /etc/lilo.conf ;   *  #lilo   ausführen/installieren ;
#     * zur leichteren Benutzung ggf. in /boot  links zu vmlinuz, System.map, config, initrd.gz  ohne Version-Nr setzen
#  
#
### ================ Paket zu bilden:   Name, Version, Art, Hersteller
LEER=" "
# ****** Eingeben / ändern : *********
NAME="e2fsprogs"        # %%%  Name des Quelltextes .tar.bz2    Kernel:   NAME=linux .  Bei NAME="" diesen Ordner packen 
VERSION="1.39-tyt3"    # %%%   [minimaler Teil von] Version des Quelltextes .tar.bz2    VERSION=2.6.22-rc7
ZUSATZ=""      # -git7     #  meist =" ": mit - im Namen .tgz gewünscht aber in NAME,VERSION der .tar.bz2 ggf nicht enthalten  ZUSATZ=-git8 
ARCH="i486"         # %%%  ARCH=i486 
BUILD="VL-1"           # %%%  BUILD=1mn   #### !!! Achtung, für Kernel   -$ARCH-$BUILD$DISTRO  in config  eingeben !!!

PATCH="patch" ;  PATCHART="git"         # Name des patches ind./generisch, nur relevant falls patch vhd.  Kernel: patch / gif
# PATCH=$NAME ;  PATCHART="dif"         # für meiste Programme $NAME / dif

NOTMAKE=0                     # siehe oben

CONFIGURE="./configure "      # falls NICHT Kernel und NOTMAKE=0  ergänzen durch geeignete Parameter, etwa --prefix=/usr  etc

HEADERS=0     # Nur relevant für Kernel: !=0 falls Kernel-Headers von /usr/src/linux-$... nach /usr/include hin installiert wd

TBZ2DIR=/downloads/Programs            #   Wo die downgeladenen / einzugebenden *.tar.bz2 oder *.tar.gz sind 
TMP=/tmp                                 #   Baustelle,      $TMP/src  Entpackung ;  $TMP/pkg  Package-Baum
PWDINIT=`pwd`                            #   Von wo aus gestartet wurde

### nicht ändern:
NAME1=`expr substr $NAME 1 1`          # <--  This is correct !!!  That here comes a expr error reclamation, shows notten else
   echo "Name fängt an mit:"  $NAME1   #      than what a shit is bash, and Linux generally   :(  Only progs from drugged jonkys 
   if test $NAME1 = $LEER ; then       # <--  Same thing here 'unary operator expected'     
   NOTMAKE=2 ;                                        #  Falls kein Name, aktuelles dir packen, seinen Namen übernehmen
   NV=${PWDINIT##*/}                   #   kpl. Name alles nach letztem /
   NAME=${NV%%-[0,1-9]*}
   VERSION=${NV#$NAME-}           
#  ZUSATZ=""                                          #   im Prinzip oben beliebig wählbar 
   fi         
   NV=$NAME-$VERSION   # [minim. Teilmenge von]  Name+Version des .tar.bz2   NV=linux-2.6.22-rc7
   VERSIONTGZ=$VERSION$ZUSATZ-$ARCH-$BUILD$DISTRO     #  Version des Paketes     VERSIONTGZ=2.6.22-rc7-git8-i486-1mn
   NAMETGZ=$NV$ZUSATZ-$ARCH-$BUILD$DISTRO   #  kpl. Name des Paketes   NAMETGZ=linux-2.6.22-rc7-git8-i486-1mn
                      
   PATCHTOTAL=$PATCH-$VERSION*$PATCHART*             # normal bei Kernel: $PATCH=patch / $PATCHART=git , sonst =$NAME / diff

  KERNEL=0    ### ================ Ob Kernel (mit/ohne Headers) oder Programm zu packen ??
   if test $NAME = linux ; then KERNEL=1 ; fi ;
   if test $NAME = kernel ; then KERNEL=2 ; fi ; 

   if test $NOTMAKE = 2 ; then SOURCEDIR=$PWDINIT ; SRCSDIR=${SOURCEDIR%/*} ;   # NAME.NE."" auch anders als subdir wählbar    
   else  # if test $NOTMAKE != 2 ; then
   if test $KERNEL != 0 ; then  SRCSDIR=/usr/src ;  SOURCEDIR=$SRCSDIR/$NAMETGZ                      
                       else  SRCSDIR=/usr/local/src ;  SOURCEDIR=$SRCSDIR/$NV$ZUSATZ ; fi;   
   fi

#  chown -R root:root $SOURCEDIR
### Anweisungen für Skript der Installierung    /install/doinst.sh   Je nach Programm ausfüllen !!
if test $KERNEL = 0 ; then             #   Für Programme     (nicht Kernel):
cat << EOF > $TMP/doinst.sh
#
EOF
fi
if test $KERNEL != 0 ; then            #   Für Paket     linux   (Kernel):
RDEVX=`rdev` 
RDEV=${RDEVX%%" "/}           # root-device wohin Kernel oder System installiert wird
RDEV0=${RDEVX%%[0,1-9]*" "/}      # zugehöriges Gerät
cat << EOF > $TMP/doinst.sh
#
rdev /boot/vmlinuz-$VERSIONTGZ $RDEV
echo "#
# hinzugefügt vom MonkeynetLinux Install-Programm
image = /boot/vmlinuz-$VERSIONTGZ
  root = $RDEV
  label = $VERSION$ZUSATZ
  read-only
  vga=791"  >> /etc/lilo.conf               #   lilo config-File machen
lilo    -b $RDEV0                           #   lilo installieren 
cp -f /boot/map /boot/map-$VERSIONTGZ
sync
echo "Kernel " $VERSIONTGZ "installiert nach " $RDEV " , LILO nach " $RDEV0  ":)"
echo "Nicht vergessen /etc/rc.d/rc.modules[.neu] zu überprüfen"
echo "   und ggf. in /etc/lilo.conf automatischen Zusatz umbenennen/umsortieren"
echo "   und #lilo nochmal laufen lassen"
echo "ggf. initrd bilden:  #mkinitrd -c -k $VERSIONTGZ "
echo "         -m jbd2:ext4dev:ext2:ext3:minix:reiserfs -r $RDEV -f ext4dev "
echo "   danach Eintrag in  /etc/lilo.conf: initrd=initrd.gz ; und   #lilo   ausführen"
echo "Nach dem booten in diesen Kernel können ältere Pakete linux oder kernel desinstalliert"
echo "   werden.     Ferner versionsabhängige Programme neu installieren / übersetzen, "
echo "   u.a.  fuse, ntfs-ng3, btrfs, linux-wlan, usw;  "
echo "   und #linux_logo > /etc/issue ; #depmod -a ; #ldconfig   ausführen "
#
EOF

if test $HEADERS != 0 ; then            #   Falls Kernel-Headers
cat << EOF >> $TMP/doinst.sh
#
echo "*** Die Kernel-Headers wurden von $SOURCEDIR/include nach /usr/include  verschoben !!!"
echo "*** Das macht die Verwendung (ggf. sofortige Erzeugung) einer glibc mit diesem Kernel erforderlich !!!"
#
EOF
else
cat << EOF >> $TMP/doinst.sh
#
echo "*** Die Kernel-Headers wurden NICHT von $SOURCEDIR/include nach /usr/include  kopiert !!!"
echo "*** Falls Programme übersetzt werden sollen, möglichst kernel-headers derjenigen Version des Systemes installieren"
echo "*** welche zur Übersetzung der zZt installierten glibc verwendet worden waren; bzw. ein bei der bisherigen Installierung"
echo "*** vhd. Pahet Kernel-Headers nicht desinstallieren.       Falls unklar/nicht vhd,  die neu "
echo "*** installierten header wie beschrieben kopieren, aber das macht die Verwendung (ggf. sofortige Erzeugung) einer " 
echo "*** glibc mit diesem Kernel erforderlich !!!"
#
EOF
fi   # headers

fi   # kernel !=0

# ********  (individuell zu ändernde Teile dieses Skriptes beendet) **********
###

               echo "*** zu erstellendes Paket:  "   $NAMETGZ.tgz    
  echo "*** Quelle:   ifKernel: " $KERNEL " Headers (relevant nur für Kernel): " $HEADERS "   ifNotMAKE: " $NOTMAKE    
  echo "       alle Quell-Ordner in: " $SRCSDIR "   dieser Quellordner: " $SOURCEDIR
  echo "       Name: " $NAME "   Version: " $VERSION "   Zusatz: " $ZUSATZ    
  echo "       Arch: " $ARCH "   BUILD: " $BUILD "   DISTRO: " $DISTRO
  echo "*** Install-Shell: "
  cat $TMP/doinst.sh
  echo "***"                
               
#echo -e "Packen:  \c"
#if test $KERNEL != 0 ; then    
#   echo "Kernel"
#   if test $HEADERS = 0 ; then  echo -e "Keine \c" ; else  echo -e "Doch \c" ; fi ;  
#   echo "Kernel-Headers von  /usr/src/"$NAMETGZ  "  nach  /usr/include  installieren  und Verweis zu Erstem" 
#else
#   echo "Programm"  
#fi

### ================ Ausgabe der zu bearbeitenden Dateien
               echo "Baustelle Quell-Entpackung / Paketbildung:  " $TMP 
# noch einbauen, test für $NOTMAKE !=0 ob $SOURCEDIR da, wenn nicht, NOTMAKE=0 setzen               
if test $NOTMAKE != 0 ; then
               echo "* schon entpackter / vorhandener Quellkode in:  "  $SOURCEDIR  "  verwenden "
fi
if test $NOTMAKE = 0 ; then  rm -r $SOURCEDIR 2> /dev/zero  ;   mkdir -p $SOURCEDIR      # $SOURCEDIR nicht löschen bei $NOTMAKE>0 
               echo "entpackter Quellkode kommt in:  "  $SOURCEDIR
               echo "insgesamt gefundene evtl. relevante Eingabedateien: "
ls -l  $TBZ2DIR/$NAME-$VERSION*
               echo "* davon verwendeter Quellcode: letzter von: "
ls -l  $TBZ2DIR/$NV*.tar.*
               echo "* anzuwendende patchs:"
ls -l  $TBZ2DIR/$PATCHTOTAL
  if test $KERNEL = 0 ; then
               echo "* Konfiguration für make:"  $CONFIGURE
  fi               
fi
if test $KERNEL != 0 ; then
  if test $HEADERS != 0 ; then 
       echo "*** WARNUNG !!  Die vorhandenen Kernel-Headers werden durch neue ersetzt !!!"
       echo "*** Das macht die Installierung oder Übersetzung der glibc für diesen Kernel nötig !!!"
  fi  
fi               

TGZ=$TBZ2DIR/$NAMETGZ.tgz               # Paket kommt in download-Ordner wo auch das .tar.bz2 ist
rm -f $TGZ  2> /dev/zero                                # Alte Pakete ggf. löschen
               echo "* zu erstellendes Paket:  "   $TGZ

#
#  2) Vorbereitungen
#

# mkdir -p $TMP   ... aber als schon vhd angenommen, bzw durch nachfolgende rekursive Anweisung erstellt

PKG=$TMP/pkg          # wo Paket-Struktur gebaut wird
rm -r $PKG  2> /dev/zero          # Löschen von altem Kram jedenfalls nötig;  manuelle Übersetzung ohne clean ggf in $SOURCEDIR
mkdir -p $PKG/usr  
               echo "* Struktur vom Paket kommt in Ordner: "  $PKG 

rm -r $TMP/src  2> /dev/zero
mkdir -p $TMP/src                        # dorthin vorläufiges Entpacken, da Fallunterscheidung jenachdem wie Ordner im .tar.bz2 benannt
               echo "vorläufige Entpackung von Programm in:  "  $TMP/src   

##  3) Arbeit 

if test $NOTMAKE = 0 ; then
### ================ Entpacken
               echo "Entpacken nach:  "  $TMP "  , vorläufig nach:  "  $TMP/src
tar -C $TMP/src -zxf $TBZ2DIR/$NV*.tar.gz  2> /dev/zero   #  /downloads/Programs/prg-1.0.tar.gz --> /tmp/prg-1.0
tar -C $TMP/src -jxf $TBZ2DIR/$NV*.tar.bz2  2> /dev/zero  #   entweder .gz oder .bz2 , daher beide lassen
#    Quellcode ist jetzt entpackt in:   $TMP/src ohne Ordner; $TMP/src/NAME* ; oder sonstwo; nach besser definierten Ort $SOURCEDIR verschieben:
mv -f $TMP/src/$NAME*/* $SOURCEDIR      # sehr wichtig , falls Version-Nr fehlt, oder Name Paket anders als Ordner
rm -r $TMP/src/$NAME* 
mv -f $TMP/src/* $SOURCEDIR             # Quellcode zum definitiven Platz verschieben 

               echo "in Ordner vom entpackten Quellkode gehen : "  $SOURCEDIR 
cd $SOURCEDIR          #  cd /downloads/Programs/SlackBuild/prg-1.0  ,  -->  .../pkg   prg-1.0-i486-1mn.tgz erzeugen

if test $KERNEL != 0 ; then    
cp /boot/config  $SOURCEDIR/.config               #### falls kein anderes config vhd , das vom lfnd. System verwenden
cp $TBZ2DIR/config-$VERSION*  $SOURCEDIR/.config    ####  ./config muss schon auf neuen Kernel angepasst sein, in .bz2 -Ordner
fi
cp $TBZ2DIR/$PATCHTOTAL  $SOURCEDIR
bzip2 -d $SOURCEDIR/$PATCHTOTAL.bz2                   # Anwendung aller patchs
patch -p 1 < $SOURCEDIR/$PATCHTOTAL  

ls -l 

### ================== Übersetzen, Installieren, Optimieren
    echo "konfigurieren,   make machen, make install nach .../pkg.    "
    if test $KERNEL = 0 ; then
#CFLAGS="-march=$ARCH -mcpu=$ARCH"  $CONFIGURE

./configure \
  --prefix= \
  --datadir=/usr/share \
  --enable-elf-shlibs \
  --enable-dynamic-e2fsck \
  $ARCH-slackware-linux                 #### e2fsprogs

echo  "*** Übersetzen ..." 
make -j3 || exit 1        #### e2fsprogs



else
echo  "*** Bitte Konfiguration überprüfen - incl. (genau) Name/Patch, lokale Bezeichng - , ggf, korrigieren !!!"
make silentoldconfig                  #### Kernel.  
#sleep 9
make menuconfig                         #### Kernel,  nochmals Chance die Einstellungen zu überprüfen, weg falls batch-Betrieb
echo  "*** Übersetzen  (dauert !!!) ..."
make -kiB                                    ### Kernel mit Option -kiB,  übersetzen selbst wenn einige neue Module Probleme haben ... 
make htmldocs                          #### Kernel
fi
# else   if test $NOTMAKE != 0 ; then
echo "      Ordner mit Quelldaten, Übersetzung  mit make schon gemacht: "
cd $SOURCEDIR
ls -l
fi

echo "*** Installieren  /  make install   nach "  $PKG   
if test $KERNEL = 0 ; then            
make DESTDIR=$PKG install             #  PROGRAMME:        entweder/oder:   DESTDIR=  ;  ROOT=    ;    prefix=   
make install-libs DESTDIR=$PKG        #### e2fsprogs
make findsuper                        #### e2fsprogs 
make clean
fi

if test $KERNEL != 0 ; then
make -kiB install                      #   KERNEL:       normal installieren, evtl -kiB   (#nm vmlinuz System.map)
make -kiB modules_install                   #   KERNEL:     Module installieren, evtl -kiB   
  if test $HEADERS != 0 ; then
  make headers_install_all                   # Normalerweise   manuell und nur  sobald glibc übersetzt wird  !!!!!
  make headers_check_all
  fi
make clean    
rm .config.old 
cp -f $SOURCEDIR/.config /boot/config   ### Kernel
cp -f /boot/config /boot/config-$VERSIONTGZ   #### Kernel
cp -f /boot/vmlinuz /boot/vmlinuz-$VERSIONTGZ  #### Kernel
cp -f /boot/System.map /boot/System.map-$VERSIONTGZ  ### Kernel
#fi
#if test $KERNEL != 0 ; then
####  =====================  Kernel:  kopieren von Source, Kernel, Modules, rc-Skripts nach PKG=/tmp/pkg
echo "*** Vorbereitung vom Packen:    "
echo "KERNEL SOURCE:   kopieren: $SOURCEDIR   nach   $PKG$SRCSDIR"
                 echo "      und link:   ln -sf $SOURCEDIR $PKG$SRCSDIR/linux"       # nötig 
                 echo "$SOURCEDIR : "  
                 ls $SOURCEDIR
      mkdir -p $PKG$SRCSDIR                                 #### Kernel: Quell-Kode        $PKG/usr/src              machen
      cp -a $SOURCEDIR $PKG$SRCSDIR                         ####    "
                 echo "ln -sf $SOURCEDIR $PKG$SRCSDIR/linux"
      ln -sf $SOURCEDIR $PKG$SRCSDIR/linux       ####   link  von  /usr/src/linux-<Version> nach /usr/src/linux machen
      ln -sf $SOURCEDIR $PKG$SRCSDIR/$NAME-$VERSION$ZUSATZ  ####   link nach Version ohne Zusätze

echo "KERNEL MODULES:  kopieren:  /lib/modules/*$VERSIONTGZ* nach $PKG/lib/modules "
                 echo "/lib/modules/*$VERSIONTGZ* : "  
                 ls /lib/modules/*$VERSIONTGZ*
      mkdir -p $PKG/lib/modules                             #### Kernel: Module machen
      cp -a /lib/modules/$VERSIONTGZ $PKG/lib/modules 

echo "KERNEL MODULES KONFIG:  kopieren:  /etc/rc.d/rc.modules nach  $PKG/etc/rc.d/rc.modules.new"
                 echo "/etc/rc.d/rc.modules : "  
                 ls /etc/rc.d/rc.modules
      mkdir -p $PKG/etc/rc.d                                #### Kernel:  /etc/rc.d/rc.modules   kopieren
      cp /etc/rc.d/rc.modules  $PKG/etc/rc.d/rc.modules.new

echo "KERNEL PROGRAMM:   kopieren:   /boot/$VERSIONTGZ*   nach   $PKG/boot"
                  echo "/boot/*$VERSIONTGZ* : "  
                  ls /boot/*$VERSIONTGZ*
      mkdir -p $PKG/boot                                    #### Kernel: ausführbarer Kernel   in /boot kopieren 
      cp /boot/*$VERSIONTGZ*  $PKG/boot                     #### alle Kernel mit gl.Version kopieren da ggf. mehrere gebaut wurden

  if test $HEADERS != 0 ; then
echo "KERNEL HEADER:  move  $PKG$SOURCEDIR/include  nach  $PKG$SRCSDIR/usr  "
                   echo "      und link    ln -sf /usr/include $PKG$SOURCEDIR/include  "
                   echo "$PKG$SOURCEDIR/include :"  
                   ls $PKG$SOURCEDIR/include   
     #mkdir -p $PKG/usr                                    #### Kernel:  header  kopieren
      mv -f $PKG$SOURCEDIR/include $PKG/usr                # Normalerweise   manuell und nur  sobald glibc übersetzt wird  !!!!!

                   echo "ls $PKG/usr/include : "  
                   ls $PKG/usr/include  
     #rm $PKG$SOURCEDIR/include
      ln -sf /usr/include $PKG$SOURCEDIR/include
  fi

rdev -R $PKG/boot/vmlinuz* 0
rdev -v $PKG/boot/vmlinuz* 0
rdev -r $PKG/boot/vmlinuz* 0 
fi

####  Kernel fertig kopiert.     


#### e2fsprogs Anfang

mkdir -p $PKG/usr/lib/pkgconfig
mv $PKG/lib/pkgconfig/* $PKG/usr/lib/pkgconfig
rmdir $PKG/lib/pkgconfig
( cd $PKG
  find . | xargs file | grep "executable" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
  find . | xargs file | grep "shared object" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
)
( cd $PKG
  rm -f man/man1/compile_et.1 man/man3/uuid_generate_random.3 man/man3/uuid_generate_time.3 man/man8/fsck.ext2.8 man/man8/fsck.ext3.8 man/man8/mkfs.ext2.8 man/man8/mkfs.ext3.8
  gzip -9 man/man?/*
  ( cd man/man3
    ln -sf uuid_generate.3.gz uuid_generate_random.3.gz
    ln -sf uuid_generate.3.gz uuid_generate_time.3.gz 
  )
  ( cd man/man8
    ln -sf e2fsck.8.gz fsck.ext2.8.gz
    ln -sf e2fsck.8.gz fsck.ext3.8.gz
    ln -sf e2fsck.8.gz fsck.ext4.8.gz
    ln -sf e2fsck.8.gz fsck.ext4dev.8.gz
    ln -sf mke2fs.8.gz mkfs.ext2.8.gz
    ln -sf mke2fs.8.gz mkfs.ext3.8.gz
    ln -sf mke2fs.8.gz mkfs.ext4.8.gz
    ln -sf mke2fs.8.gz mkfs.ext4dev.8.gz
  )
  mkdir usr
  mv bin include info man usr
  mkdir usr/lib
  mv lib/*.so lib/*.a usr/lib
)
# Junk removal
rm -f $PKG/usr/bin/compile_et $PKG/usr/bin/mk_cmds $PKG/usr/man/man1/compile_et.1.gz $PKG/usr/man/man8/fsck.ext2.8 $PKG/usr/man/man8/fsck.ext3.8 $PKG/usr/man/man8/mkfs.ext2.8 $PKG/usr/man/man8/mkfs.ext3.8
## Anyone care for these?  I don't. [NOTE:  XFS utils link with libuuid.a]
##rm -f $PKG/usr/lib/*.a
( cd $PKG/sbin
  rm -f mkfs.ext2 mkfs.ext3 mkfs.ext4 mkfs.ext4dev fsck.ext2 fsck.ext3 fsck.ext4 fsck.ext4dev e2label findfs
  ln -sf mke2fs mkfs.ext2
  ln -sf mke2fs mkfs.ext3
  ln -sf mke2fs mkfs.ext4
  ln -sf mke2fs mkfs.ext4dev
  ln -sf tune2fs e2label
  ln -sf tune2fs findfs
  cat << EOF > fsck.ext2
#!/bin/sh
exec /sbin/e2fsck -C 0 \$*
EOF
  cat << EOF > fsck.ext4
#!/bin/sh
exec /sbin/e2fsck -C 0 \$*
EOF
  cat << EOF > fsck.ext4dev
#!/bin/sh
exec /sbin/e2fsck -C 0 \$*
EOF
  cat << EOF > fsck.ext3
#!/bin/sh
exec /sbin/e2fsck -C 0 \$*
EOF
  chmod 755 fsck.ext2 fsck.ext3 fsck.ext4 fsck.ext4dev
)

 ( cd misc 
   make findsuper
   cat findsuper > $PKG/sbin/findsuper
   chmod 755 $PKG/sbin/findsuper )

mv $PKG/etc/mke2fs.conf $PKG/etc/mke2fs.conf.new
mv $PKG/share/* $PKG/usr
rm -r $PKG/share

#### e2fsprogs Ende



### Nur für Programme:         ( Den Kernel nicht strippen, auch sonst nichts im Kernel-Paket)
if test $KERNEL = 0 ; then
strip $PKG/bin/*
strip $PKG/sbin/* 
strip --strip-unneeded $PKG/lib/*.so
strip $PKG/usr/bin/*
strip $PKG/usr/sbin/* 
strip --strip-unneeded $PKG/usr/lib/*.so
strip $PKG/usr/local/bin/*
strip $PKG/usr/local/sbin/* 
strip --strip-unneeded $PKG/usr/local/lib/*.so
#strip --strip-unneeded $PKG/usr/lib/$NAME/plugins/1.0.0/*.so             # %%%
#strip --strip-unneeded $PKG/usr/lib/$NAME/plugins/1.0.0/post/*.so        # %%%
#strip --strip-unneeded $PKG/usr/lib/$NAME/plugins/1.0.0/vidix/*.so       # %%%
fi

### ================== Dokumente: entweder nach /usr/doc (normal) oder nach prefix/doc
mv -f $PKG/usr/local/doc $PKG/usr/                   # nach Standard-Platz kopieren
mv -f $PKG/usr/share/doc $PKG/usr/                   # nach Standard-Platz kopieren
mv -f $PKG/usr/local/share/doc $PKG/usr/                   # nach Standard-Platz kopieren

### Einige Anleitungen in /usr/doc
DOCDIR=$PKG/usr/doc/$NAMETGZ
mkdir -p $DOCDIR 
mv -f $PKG/usr/doc/$NAME/* $DOCDIR     # falsch
                echo "Dokumente nach: "   $DOCDIR   
cd $SOURCEDIR
cp -a \
AUTHORS COPYING CREDITS ChangeLog INSTALL NEWS README TODO \
$DOCDIR
gzip $PKG/usr/man/man1/*                         # man-pages zippen
### ==================  SlackBuild  und Text-File .txt kopieren
mkdir -p $PKG/install
#  default falls nichts besseres vorhanden:
cat << EOF > $PKG/install/slack-desc
$NAME:  $NAMETGZ  
$NAME:
$NAME:
$NAME:
$NAME:
$NAME:
$NAME:
$NAME:
$NAME:
$NAME:
$NAME: $DISTRONOTE
EOF
cp -f $PKG/install/slack-desc $TMP/slack-desc.ini
   echo "Kandidaten für slack-desc in subdir TBZ2DIR,SOURCEDIR,PWDINIT:" $TBZ2DIR , $SOURCEDIR , $PWDINIT
   echo "   NAMETGZ, NAME* :"  $NAMETGZ   " ,   "   $NAME*
ls -l $TBZ2DIR/$NAMETGZ.txt   
ls -l $TBZ2DIR/$NAME*.slack-desc
ls -l $SOURCEDIR/$NAME*.slack-desc
ls -l $PWDINIT/$NAME*.slack-desc

echo "Versuch kopieren:" $TBZ2DIR/$NAMETGZ.txt  $PKG/install/slack-desc             # niederste Priorität: altes .txt  auf Sammel-Dir aller Progs 
cp -f $TBZ2DIR/$NAMETGZ.txt  $PKG/install/slack-desc             # niederste Priorität: altes .txt  auf Sammel-Dir aller Progs 
echo "Versuch kopieren:" $TBZ2DIR/$NV*.slack-desc  $PKG/install/slack-desc   # höhere Priorität: ggf. upgedatetes File
cp -f $TBZ2DIR/$NV*.slack-desc  $PKG/install/slack-desc   # höhere Priorität: ggf. upgedatetes File
echo "Versuch kopieren:" $SOURCEDIR/$NV*.slack-desc  $PKG/install/slack-desc   # höhere Priorität: ggf. upgedatetes File
cp -f $SOURCEDIR/$NV*.slack-desc  $PKG/install/slack-desc   # höhere Priorität: ggf. upgedatetes File
echo "Versuch kopieren:" $PWDINIT/$NV*.slack-desc  $PKG/install/slack-desc   # höchste was im Ordner ist von wo gestartet wurde
cp -f $PWDINIT/$NV*.slack-desc  $PKG/install/slack-desc   # höchste was im Ordner ist von wo gestartet wurde
      if cmp $PKG/install/slack-desc $TMP/slack-desc.ini ; then 
         echo " ****> Beschreibung vom Programm ausfüllen !!!"     # für neue Pakete; für alte vhd. slack-desc schon vorher ändern !
         sleep 5
         mcedit $PKG/install/slack-desc  
      fi 
echo "definitives zurück kopieren:" $PKG/install/slack-desc  $TBZ2DIR/$NV$ZUSATZ.slack-desc.new  #      "   nach /downloads/Programs/prog-1.0-i486-1mn
cp -f $PKG/install/slack-desc  $TBZ2DIR/$NV$ZUSATZ.slack-desc.new  #      "   nach /downloads/Programs/prog-1.0-i486-1mn

echo "Versuch kopieren:" $TBZ2DIR/$NV*.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild   # letztes *.SlackBuild --> /usr/doc/...
cp -f $TBZ2DIR/$NV*.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild   # letztes *.SlackBuild --> /usr/doc/...
echo "Versuch kopieren:" $SOURCEDIR/$NV*.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild   # letztes *.SlackBuild --> /usr/doc/...
cp -f $SOURCEDIR/$NV*.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild   # letztes *.SlackBuild --> /usr/doc/...
echo "Versuch kopieren:" $PWDINIT/$NV*.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild  # falls gepatchtes Skript läuft, halt .sonstwas nennen
cp -f $PWDINIT/$NAME*.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild  # falls gepatchtes Skript läuft, halt .sonstwas nennen
echo "Versuch kopieren:" $SOURCEDIR/auto.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild   
cp -f $SOURCEDIR/auto.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild   # höchste Priorität: $SOURCEDIR/auto.SlackBuild
echo "definitives zurückkopieren:"  $DOCDIR/$NAMETGZ.SlackBuild  $TBZ2DIR/$NV$ZUSATZ.SlackBuild.new
cp -f  $DOCDIR/$NAMETGZ.SlackBuild  $TBZ2DIR/$NV$ZUSATZ.SlackBuild.new

echo "Install-Shell kopieren:" $TMP/doinst.sh $PKG/install/doinst.sh      
cp -f $TMP/doinst.sh $PKG/install/doinst.sh                        #  Install-Anweisungen  kopieren

### =================  Attribute setzen

if test $KERNEL != 0 ; then
chmod -R 755 $PKG/etc/rc.d/rc.modules.new
fi

if test $KERNEL = 0 ; then
#chown -R root.root $PKG/usr/doc
#chmod -R 644 $PKG/usr/doc/$NV/*
#chown -R root.root $PKG/usr/include
#chown -R root.root $PKG/usr/man
#chown -R root.root $PKG/usr/share
chown -R root.root $PKG
chown -R root.bin $PKG/bin                   # verschiedene Prioritäten setzen
chown -R root.bin $PKG/usr/bin                   # verschiedene Prioritäten setzen
chown -R root.bin $PKG/usr/local/bin                   # verschiedene Prioritäten setzen
fi

### ==================== Paket aus Paket-Struktur ./pkg bilden  
echo "*** Paket bilden:  "   $NAMETGZ.tgz  " ,   md5sum:  dgl. .md5  ,  Text:  "  $NAMETGZ.txt  "   alles nach: "  $TBZ2DIR 
cd $PKG
makepkg -l y -c n $TGZ        # makepkg ... /downloads/Programs/prog-1.0-i486-1mn.tgz	
cd $TBZ2DIR
md5sum $TGZ > $TGZ.md5
cp -f $PKG/install/slack-desc  $TBZ2DIR/$NAMETGZ.txt  
### ====================  Falls mit --cleanup aufgerufen, säubern
if [ "$1" = "--cleanup" ]; then
rm -rf $SOURCEDIR 
#rm -rf $PKG   # schon in vorigem
fi
