#! /bin/bash
#
### * 1) Einzugebende Definitionen  (bleiben meist unverändert)
#
DISTRO="sys"                                     # Neuste Version dieses Skriptes ist in den neusten  Paketen
DISTRONOTE="Paket von W.Landgraf  SYS / MONKEYNET Linux  www.monkey.is-a-geek.net/tgz"
#                                                   Pakete kompatibel mit Slackware current
RDEV=/dev/sda2 ; RDEVFMT=ext3                   #  nur für initrd nötig
#
#
# 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:ext4: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.cpio.gz  ohne Version-Nr setzen
#  
#
### ================ Paket zu bilden:   Name, Version, Art, Hersteller
LEER=" "
LEER0=
# ****** Eingeben / ändern : *********
NAME=" "        # %%%  Name des Quelltextes .tar.bz2    Kernel:   NAME=linux .  Bei NAME=" " den aktuellen Ordner packen 
VERSION=""    # %%%   [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="1"      # %%%  BUILD=1mn   #### !!! Achtung, für Kernel geht nur "1" ; und  -$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


KOPIEREN=extra    # einfaches Kopieren eines Ordners von $SOURCEDIR nach $DOC  ( besonders bei $NOTMAKE >0 manuell hinzufügbar)   
                  # !!!   Mit/ohne / eingeben falls absolut bzw. relativ zu $SOURCEDIR  .  
                  # Wird kopiert OHNE / ausserhalb / eine Instanz höher  dem Ordner  $KOPIEREN !!

NOTMAKE=0                     # siehe oben
HEADERS=0     # Nur relevant für Kernel: !=0 falls Kernel-Headers von /usr/src/linux-$... nach /usr/include hin installiert wd
KEEPSRC=2     # KEEPSRC=0,1,2 falls Übersetzung anschliessend löschen, clean, unverändert lassen
              #    Kernel wird immer gecleant
IFINSTALL=0   # IFINSTALL=0,1,2 falls gemachtes Paket 1=installieren, 2=updaten   für Programme, Kernel NIE installieren/updaten
KERNELDOCS=1  # Dokumente vom Kernel: 0=loeschen  1=installieren und in source lassen

PUB=/pub           # Wohin ggf. Kopie der Pakete sollen

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

PREFIX0=/usr                       #   --prefix  für ./configure        muss absolut sein, mit / beginnen !!
                                   #       ACHTUNG !!   Dieses Skript fängt die meisten Nachlässigkeiten  der Programmierer ab,
                                   #                    aber in seltenen Fällen ist es nötig, unten Parameter für
                                   #                    ./configure  ,  make , make install  abzuändern / hinzuzufügen    
### 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'     
      echo "*** Name des Paketes wird gebildet aus PWD initial:  "   $PWDINIT   
   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-}        #  Bei Programmen:  ZUSATZ, ARCH, DISTRO im Namen des Ordners NICHT enthalten, oben angeben !!
   fi         

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

   if test $KERNEL != 0 ; then
   if test $NAME1 = $LEER ; then       
   VERSIONTGZ=$VERSION
   REST=${VERSIONTGZ%-[0,1-9]*}             
   BUILDDISTRO=${VERSIONTGZ#$REST-}            #  1mn    Sollte mind. die Nr. vhd sein
   BUILD=${BUILDDISTRO%%[a-z,A-Z]*}
   DISTRO=${BUILDDISTRO#$BUILD}            #  nicht nötig.   zBsp   mn
   VERSION=${REST%-[a-z,A-Z]*}             #  VERSION enthält hier bereits Zusätze wie -rc2 , -git7, also ZUSATZ=""    
   ARCH=${REST#$VERSION-}                  #  Nötig. Später einbauen:   Falls nicht  arch oder iX86, wird durch i486 ersetzt
   ZUSATZ=""
   fi         
   fi

   if test $NAME1 = $LEER ; then
       echo "***  aus PWD gebildet:                 NAME: " $NAME " , VERSION: " $VERSION   
       echo "***      PWD(Kernel)/Vorgabe(Progs):   ZUSATZ: " $ZUSATZ " , ARCH: " $ARCH " , BUILD: " $BUILD " , DISTRO: " $DISTRO         
   fi

   VERSION0=${VERSION%-*}                  #  VERSION0  Klasse zBsp 2.6.28.7 fuer link    
   
   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


   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

 TMP=$TMP0/$NAMETGZ                       #  nötig , da falls mehrere Programme laufen, das letzte alles der anderen löscht
 rm -r $TMP  2> /dev/zero
 mkdir -p $TMP

echo "0 TMP: "  $TMP > $TMP/test.test
ls  $TMP  >> $TMP/test.test
 
touch $PWDINIT/doinst.sh  ; cat  $PWDINIT/doinst.sh > $TMP/doinst.sh           # Vorspann/Zusatz von doinst.sh  kopieren    
#  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)  nur dies:
cat << EOF >> $TMP/doinst.sh    
#
EOF
#fi


if test $KERNEL != 0 ; then            #   Für Paket     linux   (Kernel):

VZ=$VERSION$ZUSATZ  ;  VZ=${VZ//./$LEER0}  ;  VZ=${VZ//-/$LEER0}          # Version-Nr ohne - und .
VZTXT=$VZ'txt' ; VZIRD=$VZ'ird'     # again, because bash is soooo stupid and unlogical, one cannot write this direcly, below

echo '                        # root-Gerät/Partition bei der Installierung abfragen --> RDEV0/RDEV
RDEVX=`rdev` 
RDEV=${RDEVX%%" "/}           # root-device wohin Kernel oder System installiert wird
RDEV0=${RDEVX%%[0,1-9]*" "/}      # zugehöriges Gerät 
RDEVFMT=ext3                     #  ggf. ersetzen durch $RDEVFMT oder Format von $RDEV bei Installierung abfragen
    ' >> $TMP/doinst.sh

cat << EOF >> $TMP/doinst.sh
#
echo " boot-Gerät: "  \$RDEV0  "   boot/root-Partition: " \$RDEV 
rdev /boot/vmlinuz-$VERSIONTGZ \$RDEV
echo "#
# hinzugefügt vom SYS Install-Programm
image = /boot/vmlinuz-$VERSIONTGZ
  root = \$RDEV
  label = \"$VZ\"
  read-only
  vga=791   # 785 fuer kleine laptops
  append=\"4 root=\$RDEV devfs=nomount noapic nolapic acpi=ht rootwait\"
image = /boot/vmlinuz-$VERSIONTGZ
  root = \$RDEV
  label = \"$VZTXT\"                 # hoffentlich wird das nicht zu lang ...
  read-only
  vga=0
  append=\"3 root=\$RDEV devfs=nomount noapic nolapic acpi=ht rootwait\"
#  
  "  >> /etc/lilo.conf               #   lilo config-File machen
lilo    -b \$RDEV0                           #   lilo installieren 
cp -f /boot/map /boot/map-$VERSIONTGZ
echo "   "
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:ext4:ext2:ext3:minix:reiserfs -r " \$RDEV " -f " \$RDEVFMT -w 20 -R 
echo "   danach Eintrag in  /etc/lilo.conf: initrd=initrd.cpio.gz ; und   #lilo   ausführen"
echo "Nachfolgend wird dies versucht, separat für den Fall des Fehlschlages"
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, ndiswrapper usw;  "
echo "   und #linux_logo > /etc/issue ; #depmod -a ; #ldconfig   ausführen "
echo "****"
#
rdev /boot/initrd-$VERSIONTGZ.cpio.gz \$RDEV   # initrd von anderem Rechner funktioniert idR nicht, nur für denselben wenn mkinitrd fehlschlägt
mkinitrd -c -k $VERSIONTGZ -o /boot/initrd-$VERSIONTGZ.cpio.gz  -m jbd2:ext4:ext2:ext3:minix:reiserfs -r \$RDEV -f \$RDEVFMT -w 20 -R   
echo "#
image = /boot/vmlinuz-$VERSIONTGZ
  root = \$RDEV
  initrd = /boot/initrd-$VERSIONTGZ.cpio.gz
  label = \"$VZIRD\"       
  read-only
  vga=791
  append=\"3 root=\$RDEV devfs=nomount noapic nolapic acpi=ht rootwait\"
#
    "  >> /etc/lilo.conf 
lilo    -b \$RDEV0                           #   lilo installieren 
cp -f /boot/map /boot/map-$VERSIONTGZ
sync
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 (als info nach ...-$NV$ZUSATZ) !!!"
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. Paket Kernel-Headers nicht desinstallieren.   Die Kernel-Header als nicht zum Kernel sondern zur aktuellen"
echo "*** glibc gehÃrend auffassen, und nur wÃhrend deren Neuinstallierung/Ãbersetzung Ãndern:   ./configure , make " 
echo "*** von glibc mit bisherigen headern, dann header ggf. Ãndern - von $SOURCEDIR/include nach /usr/include kopieren - ,"
echo "*** dann make install;  anschliesend am besten nochmal ./configure ,  make , make install wiederholen,  ferner"
echo "*** gcc, glib-1, glib-2, gtk+ , linux neu Ãbersetzen !!!"
#
EOF
fi   # headers

fi   # kernel !=0

echo "1 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test


# ********  (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
# 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 sofortige 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

echo "2 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test


#
#  2) Vorbereitungen
#
               echo "Baustelle Quell-Entpackung / Paketbildung:  " $TMP 
# 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     # oben: Löschen von altem Kram jedenfalls nötig;  manuelle Übersetzung ohne clean ggf in $SOURCEDIR
               echo "* Struktur vom Paket kommt in Ordner: "  $PKG 



# Bei den meisten Programmen macht #make alle nötigen Ordner - bei manchen aber nicht ... :(     :
mkdir -p $PKG/usr $PKG/usr/bin $PKG/usr/sbin $PKG/usr/man/man5 $PKG/usr/man/man8       # ggf $PKG/usr durch $PREFIX ersetzen  

#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   

echo "3 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test

if test $KERNEL = 0 ; then
###  ================= HIER GGF ANPASSEN !!!!! =====================
# für make:   Manche Programme verstehen kein DESTDIR= , andere haben kein ./configure ,  daher PREFIX etc explizit vorgeben
#    Diese Parameter müssen für ggf. vhd. ./configure  UND  make , make install    vhd sein , also vor beides setzen !!!
#DESTDIR0=$PKG               # für make
#PREFIX0=[/usr]  # gewählte Vorgabe siehe oben
#PREFIX=$PKG$PREFIX0 ; DESTDIR0=[irgendwas]        # falls #make   DESTDIR nicht kennt , dann  DESTDIR0=beliebig
#PREFIX=[irgendwas]    ; DESTDIR0=$PKG$PREFIX0     # falls kein ./config vhd,   dann PREFIX=beliebig
#PREFIX=$PREFIX0 ; DESTDIR0=$PKG           # Normalfall . Akkumulativ: PREFIX=PREFIX0 , DESTDIR0=PKG 
PREFIX=$PREFIX0 ; DESTDIR0=$PKG          
EPREFIX=$PREFIX                           #     meist überflüssig 
OLDINCLUDEDIR=$PREFIX/include

CFLAGS="-march=$ARCH -mcpu=$ARCH"  # \  
CONFIGURE=" ./configure --prefix=$PREFIX "      # falls NICHT Kernel und NOTMAKE=0  ergänzen durch geeignete Parameter 
fi                                                #       Bei Slackware ist idR  --prefix=/usr  etc

##  3) Arbeit 


if test $NOTMAKE = 0 ; then


### ================ a) 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 

cd $SOURCEDIR          #  cd /downloads/Programs/SlackBuild/prg-1.0  ,  -->  .../pkg   prg-1.0-i486-1mn.tgz erzeugen
               echo "in Ordner vom entpackten Quellkode gehen : "  $SOURCEDIR 
# konfig holen
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
cp /boot/config-$VERSION*  $SOURCEDIR/.config      
fi
# patch kopieren, patchen

cp $TBZ2DIR/$PATCHTOTAL  $SOURCEDIR
bzip2 -d $SOURCEDIR/$PATCHTOTAL.bz2                   # Anwendung aller patchs
                echo "patch :   "  $PATCHTOTAL    "   Ordner  "  $SOURCEDIR
                echo "patch :      patch -p 1 <" $SOURCEDIR/$PATCHTOTAL   "   in Ordner:  "   $SOURCEDIR  
touch .gitignore                                     #  da oft nicht vhd. aber vom patch gesucht wird
patch -p 1 < $SOURCEDIR/$PATCHTOTAL  
rm -f $PATCHTOTAL                                    #  darf bei mehrfacher Verwendung des Skriptes/Quellcodes nicht bleiben  
# zu verwendender Quellcode/Konfig listen
echo "      Ordner mit Quelldaten, mit patchs,konfig   vor Übersetzung  mit make : "
ls -l 

### ================== b) Übersetzen
    echo "konfigurieren,   make machen, make install nach .../pkg.    "
if test $KERNEL = 0 ; then
echo "  CONFIGURE :"  $CONFIGURE  
sleep 15
$CONFIGURE
echo  "*** Übersetzen ..." 

make -i 
# make PREFIX=/usr QMAKE=/opt/qt4/bin/qmake     # falls Probleme mit qt4 wie 'zu neue Version'  
# Falls python,  Uebersetzung besser in ein configure.sh stecken , ausfuehren, und dieses Programm nur zum Packen aufrufen:
#mkdir -p $KOPIEREN/usr 
# ./setup.py build --prefix=/usr 
#./setup.py install --prefix=/usr --root=$KOPIEREN 
# ./auto.SlackBuild   # nur packen
# Falls perl,  Uebersetzung besser in ein configure.sh stecken , ausfuehren, und dieses Programm nur zum Packen aufrufen:
#CFLAGS="-O2 -march=i486 -mtune=i686" perl Makefile.PL PREFIX=/usr
#make

else
ln -s asm-x86 include/asm-386   # da asm-386 usw nicht mehr da
ln -s asm-x86 include/asm-486
ln -s asm-x86 include/asm-586
ln -s asm-x86 include/asm-686
ln -s asm-x86 include/asm-786
ln -sf /usr/src/linux-$(uname -r)   /usr/src/linux     # nÃtig sonst geht neuer Kernel nicht
echo  "*** Neuigkeiten im Kernel -- bitte konfigurieren: "
####make silentoldconfig                  #### Kernel.  
echo  "*** Bitte Konfiguration überprüfen - incl. (genau) Name/Patch, lokale Bezeichng - , ggf, korrigieren !!!"
sleep 9
make menuconfig                         #### Kernel,  nochmals Chance die Einstellungen zu überprüfen, weg falls batch-Betrieb
echo  "*** Übersetzen  (dauert !!!) ..."
make -kiB  &> $TMP0/$NAMETGZ.log                              ### Kernel mit Option -kiB,  übersetzen selbst wenn einige neue Module Probleme haben ... 
make htmldocs                          #### Kernel
fi    # test $KERNEL
#cd $SOURCEDIR
echo "      Ordner mit Quelldaten, Übersetzung  mit make gerade gemacht: "
ls -l

fi    # test $NOTMAKE

echo "4 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test

### =================== c) installieren  nach $PKG

echo "*** Installieren  /  make install   nach "  $PKG 
cd $SOURCEDIR 

# Programme  
if test $KERNEL = 0 ; then            
echo  "  PREFIX:  " $PREFIX   "  , EPREFIX: " $EPREFIX
echo  "  DESTDIR: " $DESTDIR0 
#sleep 15

#make install                      # ausreichend falls DESTDIR= oben vorgegeben
make DESTDIR=$DESTDIR0 -i install     #  PROGRAMME:  DESTDIR oben vorgeben      entweder/oder:   DESTDIR=  ;  ROOT=    ;    prefix=   
                                   #            DESTDIR   muss explizit angegeben werden, ist nicht als Umgebungsvariable bekannt
#make clean
if test $KEEPSRC != 2 ; then  echo " aufraeumen:  make clean  " ;  cd $SOURCEDIR ;  make clean ; cd - ; fi ;   


mkdir -p $PKG/etc/rc.d
mv $PKG/etc/init.d/* $PKG/etc/rc.d/rc.$NAME.new
rm -r $PKG/etc/init.d
fi

# Kernel
if test $KERNEL != 0 ; then
if test $KERNELDOCS = 0 ; then  echo " Kernel -Dokumente loeschen  " ;   rm -r $SOURCEDIR/Docum*  ; fi ;   
make -kiB install  &> $TMP0/$NAMETGZ.log1                      #   KERNEL:       normal installieren, evtl -kiB   (#nm vmlinuz System.map)
make -kiB modules_install   &> $TMP0/$NAMETGZ.log2                #   KERNEL:     Module installieren, evtl -kiB   
  if test $HEADERS != 0 ; then
  make headers_install_all    &> $TMP0/$NAMETGZ.log3               # Normalerweise   manuell und nur  sobald glibc übersetzt wird  !!!!!
  make headers_check_all      &> $TMP0/$NAMETGZ.log4
  fi
# Ab 2.6.29 werden Module nach $VERSION$ZUSATZ erzeugt , davor in $VERSIONTGZ , source immer in $VERSIONTGZ
mv -f  /lib/modules/$VERSION$ZUSATZ /lib/modules/$VERSIONTGZ ; ln -s /lib/modules/$VERSIONTGZ  /lib/modules/$VERSION$ZUSATZ 
# Jetzt sind Module immer in $VERSIONTGZ mit link nach $VERSION$ZUSATZ 
sync  
#               initrd idR nicht transportabel, bei grosem Kernel auch nicht nötig, und wird bei install gemacht  
make clean         # Kernel immer make clean da sonst source voll mit Kram ins Paket kommt    
#if test $KEEPSRC != 2 ; then  echo " aufraeumen:  make clean  " ;  cd $SOURCEDIR ;  make clean ; cd - ; fi ;   

rm .config.old 
rm /boot/config ; cp -f $SOURCEDIR/.config /boot/config   
cp -f /boot/config /boot/config-$VERSIONTGZ   
cp -f /boot/vmlinuz /boot/vmlinuz-$VERSIONTGZ  
cp -f /boot/System.map /boot/System.map-$VERSIONTGZ 

  echo "5 TMP vor mkinitrd: "  $TMP >> $TMP/test.test
  ls  $TMP  >> $TMP/test.test

mkinitrd -c -k $VERSIONTGZ -o /boot/initrd-$VERSIONTGZ.cpio.gz -m jbd2:ext4:ext2:ext3:minix:reiserfs -r $RDEV -f $RDEVFMT -w 20 -R 
rm  /boot/initrd.cpio.gz ; cp -f /boot/initrd-$VERSIONTGZ.cpio.gz /boot/initrd.cpio.gz 

   echo "5 TMP nach mkinitrd: "  $TMP >> $TMP/test.test
   ls  $TMP  >> $TMP/test.test

# 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-$VERSION0 ####   Nicht in /usr/src aendern waehrend Uebersetzung
      ln -sf $SOURCEDIR $PKG$SRCSDIR/$NAME-$VERSION  ####   Achtung b ZUSATZ=""
      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 
      ln -sf /lib/modules/$VERSIONTGZ $PKG/lib/modules/$VERSION0  #### nicht waehrend Uebersetzung in /lib/modules aendern 
      ln -sf /lib/modules/$VERSIONTGZ $PKG/lib/modules/$VERSION 
      ln -sf /lib/modules/$VERSIONTGZ $PKG/lib/modules/$VERSION$ZUSATZ 

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
      ln -sf /etc/rc.d/rc.modules $PKG/etc/rc.d/rc.modules-$VERSIONTGZ 

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 
rdev -R $PKG/boot/initrd-*.cpio.gz 0
rdev -v $PKG/boot/initrd-*.cpio.gz 0
rdev -r $PKG/boot/initrd-*.cpio.gz 0 
fi

####  Kernel fertig kopiert.     
echo "6 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test
ls $PKG$SRCSDIR  >> $TMP/test.test
ls $PKG/boot  >> $TMP/test.test

### ========== d) strippen   :   Nur für Programme:         ( Den Kernel nicht strippen, auch sonst nichts im Kernel-Paket)
if test $KERNEL = 0 ; then
( 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
  find . | xargs file | grep "current ar archive" | cut -f 1 -d : | xargs strip -g 2> /dev/null
)
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

### ================== e) Dokumente: entweder nach /usr/doc/$NAME (normal)  
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

echo "7 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test
ls $PKG$SRCSDIR  >> $TMP/test.test
ls $PKG/boot  >> $TMP/test.test

### Einige Anleitungen ref. Paket/Installierung in /usr/doc/$NAMETGZ
DOCDIR=$PKG/usr/doc/$NV$ZUSATZ  # nicht ..$NAMETGZ da manche Progs zum Funktionieren Kram aus ..$NV$ZUSATZ brauchen
# umsortieren auf einhtl. Paket-Name
DOCDIR0=$PKG/doc   # vorläufig
mkdir -p  $DOCDIR0 
    echo "  Dokumente in " $PKG/usr/doc ;  ls $PKG/usr/doc
mv -f $PKG/usr/doc/$NAME*/* $DOCDIR0    
rmdir $PKG/usr/doc/$NAME*   
mv -f $PKG/usr/doc/* $DOCDIR0
#rmdir $PKG/usr/doc/*   
                echo "Dokumente in: "   $DOCDIR0 "  , spaeter nach:  " $DOCDIR  ;  ls $DOCDIR     
    echo " Dokumente von " $DOCDIR0 "  :  " ;  ls $DOCDIR0
mkdir -p  $DOCDIR   # = $PKG/usr/doc/$NAMETGZ 
mv -f $DOCDIR0/* $DOCDIR
    echo "      kopiert nach " $DOCDIR "  :  " ;  ls $DOCDIR  
    #sleep 15
# umsortieren fertig
cd $SOURCEDIR
### ======== Einige Anwendungen wie desktop-icons kopieren
mkdir -p $KOPIEREN/usr/share/applications 
cp -f /usr/share/applications/$NAME.desktop              #  hilfsweise das icon vom momentanen System nehmen  
cp -f *.desktop $KOPIEREN/usr/share/applications 
### ======== Anwendungen fertig 
ls -R $KOPIEREN > $KOPIEREN.lst 
cp -aR \
AUTHORS *BUGS *doinst.sh conf*.sh COPYING* CREDITS ChangeLog $KOPIEREN.lst FAQ *HOWTO INSTALL NEWS LIESMICH* README* $TMP0/$NAMETGZ.log*  TODO dist \
$DOCDIR
cp -aR doc*/* $DOCDIR
### ======== docs fertig
cp -aR $KOPIEREN/* $PKG     # $KOPIEREN: einfachs Kopieren, falls $KOPIEREN vorgegeben mit / , absolut, sonst rel. zu $SOURCEDIR
mv -f $PKG/doc*/* $DOCDIR   #   Aber:  $KOPIEREN-oder-sonstwas/doc*  kommen immer in den doc-Ordner !!!

gzip $PKG/usr/man/man1/*                         # man-pages zippen

### ==================  f) 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
echo "8 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test
ls $PKG$SRCSDIR  >> $TMP/test.test
ls $PKG/boot  >> $TMP/test.test

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
cp -f $TBZ2DIR/$NV$ZUSATZ.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
cp -f $SOURCEDIR/$NV$ZUSATZ.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
cp -f $PWDINIT/$NV$ZUSATZ.slack-desc  $PKG/install/slack-desc   # höchste was im Ordner ist von wo gestartet wurde
cp -f $PWDINIT/$NAME*$DISTRO.txt  $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 "9 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test
ls $PKG$SRCSDIR  >> $TMP/test.test
ls $PKG/boot  >> $TMP/test.test


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/...
cp -f $TBZ2DIR/$NV$ZUSATZ.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/...
cp -f $SOURCEDIR/$NV$ZUSATZ.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/$NV.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild  # falls gepatchtes Skript läuft, halt .sonstwas nennen
cp -f $PWDINIT/$NV$ZUSATZ.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild  # falls gepatchtes Skript läuft, halt .sonstwas nennen
echo "Versuch kopieren:" $SOURCEDIR/*.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild   
cp -f $SOURCEDIR/*.SlackBuild  $DOCDIR/$NAMETGZ.SlackBuild   # höchste Priorität: $SOURCEDIR/*.SlackBuild
echo "definitives zurückkopieren:"  $DOCDIR/$NAMETGZ.SlackBuild  $TBZ2DIR/$NV$ZUSATZ.SlackBuild.new
cp -f  $DOCDIR/$NAMETGZ.SlackBuild  $TBZ2DIR/$NV$ZUSATZ.SlackBuild.new

echo "10 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test
ls $PKG$SRCSDIR  >> $TMP/test.test
ls $PKG/boot  >> $TMP/test.test

ls -l       $TMP/doinst.sh  
ls -l       $PKG/install/doinst.sh
#   Achtung:  schon vhd. doinst.sh nicht Ã¼berschreiben, an es anhÃ¤nge !!n
echo "Install-Shell erweitern:" $TMP/doinst.sh " an " $PKG/install/doinst.sh " anhaengen" 
sleep 20
cat $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

echo "11 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test
ls $PKG$SRCSDIR  >> $TMP/test.test
ls $PKG/boot  >> $TMP/test.test

### ==================== leere Ordner im Paketbaum löschen (nur soweit explizit angelegt, nicht die in /$KOPIEREN)
rmdir $DOCDIR $PKG/doc* $PKG/etc/rc.d $PKG/etc 
rmdir $PKG/usr/bin $PKG/usr/sbin $PKG/usr/man/man5 $PKG/usr/man/man8 $PKG/usr/man $PKG/usr       

### ==================== Paket aus Paket-Struktur ./pkg bilden  
echo "*** Paket bilden:  "   $NAMETGZ.tgz  " ,   md5sum:  dgl. .md5  ,  Text:  "  $NAMETGZ.txt  "   alles nach: "  $TBZ2DIR 
cd $PKG
if test $KERNEL = 0 ; then
requiredbuilder -v -y  $PKG   # -s $CWD einfügen
fi
ls -l ; ls -l install/*    
makepkg -l y -c n $TGZ   > /dev/zero     # makepkg ... /downloads/Programs/prog-1.0-i486-1mn.tgz	
cd $TBZ2DIR
md5sum $NAMETGZ.tgz > $NAMETGZ.tgz.md5
cp -f $PKG/install/slack-desc  $TBZ2DIR/$NAMETGZ.txt  

### ====================  aufräumen , je nach $KEEPSRC  
cd $SOURCEDIR

if test $KERNEL = 0 ; then   make DESTDIR=$DESTDIR0 uninstall ; fi ;  # falls altes Paket uninstalliert wird, diese Zeile ganz weg             
if test $KERNEL != 0 ; then   make  uninstall ; fi ;             


#if [ "$1" = "--cleanup" ]; then   ...   ; fi ;       #  Falls mit --cleanup aufgerufen, säubern
if test $KEEPSRC = 0 ; then  echo " Uebersetzung / Quellcode löschen " ;  cd .. ; rm -rf $SOURCEDIR ;  fi ;      # Normalfall
if test $KEEPSRC = 1 ; then  echo " aufraeumen:  make clean  " ;  cd $SOURCEDIR ;  make clean ; cd - ; fi ;   
#if test $KEEPSRC != 2 ; then  echo " aufraeumen:  make clean  " ;  cd $SOURCEDIR ;  make clean ; fi ;   


echo "12 TMP: "  $TMP >> $TMP/test.test
ls  $TMP  >> $TMP/test.test
ls $PKG$SRCSDIR  >> $TMP/test.test
ls $PKG/boot  >> $TMP/test.test

### =====================   Paket ggf.  installieren  je nach $IFINSTALL    Kernel NIE updaten !!!!  
cd $TBZ2DIR

      echo " KERNEL, IFINSTALL:  "   $KERNEL  "   "  $IFINSTALL
if test $KERNEL != 0 ; then  IFINSTALL=1 ; fi ;
      echo " KERNEL, IFINSTALL:  "   $KERNEL  "   "  $IFINSTALL
if test $IFINSTALL = 1 ; then  echo " Paket installieren " ;    installpkg $TGZ ; fi ; 
if test $IFINSTALL = 2 ; then  echo " Paket updaten " ;   upgradepkg --install-new --reinstall $TGZ ; fi ;     # Normalfall 

cp $NAMETGZ.tgz $PUB            # zum downloaden von $PUB freigeben
cp $NAMETGZ.tgz.md5 $PUB
cp $NAMETGZ.txt $PUB

#rm -rf $PKG   # besser jeweils VOR Paketbildung löschen, bei Fehlern anguckbar
###rm -r $TMP     # später ggf. löschen lassen                     # wenn wir hier ankommen, schon alles im Paket  





