home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / archiver / ncmp424s / build < prev    next >
Encoding:
Text File  |  1993-07-08  |  19.4 KB  |  843 lines
  1. :
  2. #!/bin/sh
  3. #
  4. version="4.2.4"
  5.  
  6. echo "Build (N)compress ${version}"
  7. CLS=`sh -c 'tput clear' 2>/dev/null`
  8.  
  9. if expr `echo "foo\c"` : '.*c' >/dev/null
  10. then
  11.     n='-n'
  12.     c=''
  13. else
  14.     n=''
  15.     c='\c'
  16. fi
  17.  
  18. trap 'rm -f /tmp/sh$$.tm* /tmp/sh$$.f* /tmp/sh$$.log /tmp/sh*.c' 0
  19. trap 'set +x ; exit 1' 1 2 15
  20.  
  21. [ -f compress.def ] && . ./compress.def
  22.  
  23. while true
  24. do
  25.     if [ "${DEFINED}" = yes ]
  26.     then
  27.         echo "${CLS}    Build (N)compress ${version}
  28.  
  29.  1.  Directory to install compress in: ${BINDIR}
  30.                           manual in  : ${MANDIR}
  31.  2.  Memory free for compress        : ${USERMEM}
  32.  3.  Input/Output buffer size        : ${IBUFSIZ} ${OBUFSIZ}
  33.  4.  C Compiler                      : ${CC}
  34.  5.  Compiler options                : ${CCOPT:---none--}
  35.  6.  Libary options                  : ${LBOPT:---none--}
  36.  7.  Special options for your system : ${EXTRA:---none--}
  37.  8.  Number of register variable     : ${REGISTERS}
  38.  9.  Symbolic links                  : ${LSTAT}
  39. 10.  Use include <utime.h>           : ${UTIME_H}"
  40.  
  41.         if [ ".${DIRENT}" = .yes ] 
  42.         then
  43.             echo "11.  Your system support dirent.h"
  44.         else
  45.             if [ ".${SYSDIR}" = .yes -a ".${DIRENT}" != .yes ]
  46.             then
  47.                 echo "11.  Your system support sys/dir.h"
  48.             else
  49.                 echo "11.  No directory support -r disabled."
  50.             fi
  51.         fi
  52.     
  53.         echo "12.  Word must start at even addres: ${NOALLIGN}, Bytorder on your system: ${BYTEORDER} (1=msb)"
  54.         echo "
  55.  d. Set default settings                    mkshar.  Create shell archive
  56.  c. Compile compress                        mktar.   Create tar archive
  57.  t. Test compress                           cleanup. Cleanup
  58.  i. Install compress                        genmake. Generate makefile
  59.  q. Stop
  60. "
  61.         echo ${n} "   Choice [1..10,d,c,t,i,q,mkshar,mktar,cleanup] : ${c}"
  62.  
  63.         (
  64.             echo "# Current parameters."
  65.             for var in CC CCOPT LBOPT BINDIR MANDIR DIRENT SYSDIR IBUFSIZ \
  66.                         OBUFSIZ USERMEM REGISTERS LSTAT BYTEORDER NOALLIGN \
  67.                         EXTRA DEFINED UTIME_H
  68.             do
  69.                 echo "${var}='`eval echo \$\{${var}\}`'"
  70.             done
  71.         ) >compress.def
  72.  
  73.         read choice var1 var2 var3 var4 varr
  74.         echo ""
  75.     else
  76.         choice=D
  77.     fi
  78.  
  79.     case "${choice}" in
  80.     1)
  81.         if [ ".${var1}" = . ]
  82.         then
  83.             echo ${n} "Directory to install compress in (default:${BINDIR}) ? ${c}"
  84.             read var1 dummy
  85.         fi
  86.  
  87.         BINDIR="${var1:-${BINDIR}}"
  88.  
  89.         if [ ".${var2}" = . ]
  90.         then
  91.             echo ${n} "Directory to install manuals in (default:${MANDIR}) ? ${c}"
  92.             read var2 dummy
  93.         fi
  94.  
  95.         MANDIR="${var2:-${MANDIR}}"
  96.         ;;
  97.  
  98.     2)
  99.         if [ ".${var1}" = . ]
  100.         then
  101.             echo "Compress use a lot of memory, the more memory it can just the faster"
  102.             echo "the programm is and the better compression is."
  103.             echo ${n} "Memory free for compress (default:${USERMEM}) ? ${c}"
  104.             read var1 dummy 
  105.         fi
  106.  
  107.         USERMEM="${var1:-${USERMEM}}"
  108.         ;;
  109.  
  110.     3)    
  111.         if [ ".${var1}" = . ]
  112.         then
  113.             echo "For input and output compress use buffers. A bigger buffer reduce"
  114.             echo "system (kernel) overhead. If your system is a 16 bits system don't"
  115.             echo "make the buffers bigger than 2048 bytes. The default 2048 is in"
  116.             echo "most cases a good answer."
  117.             echo ${n} "Best input buffer size (default:${IBUFSIZ}) ? ${c}"
  118.             read var1 var2 dummy
  119.  
  120.             if [ ".${var2}" = . ] 
  121.             then
  122.                 echo ${n} "Best output buffer size (default:${OBUFSIZ}) ? ${c}"
  123.                 read D dummy 
  124.             fi
  125.         fi
  126.  
  127.         var2="${var2:-${var1}}"
  128.          IBUFSIZ="${var1:-${IBUFSIZ}}"
  129.          OBUFSIZ="${var2:-${OBUFSIZ}}"
  130.         ;;
  131.  
  132.     4)
  133.         if [ ".${var1}" = . ]
  134.         then    
  135.             echo "C compiler to use for compilation (must by cc compatible)".
  136.             echo ${n} "C Compiler (default:${CC}) ? ${c}"
  137.             read var1 dummy
  138.         fi
  139.  
  140.         CC="${var1:-${CC}}"
  141.         ;;
  142.  
  143.     5)
  144.         if [ ".${var1}" = . ]
  145.         then
  146.             echo ${n} "Compiler options (default:${CCOPT:-none}) ? ${c}"
  147.             read var1
  148.         fi
  149.  
  150.         [ ".${var1}" != . ] && CCOPT="${var1} ${var2} ${var3} ${var4} ${varr}"
  151.         ;;    
  152.  
  153.     6)
  154.         if [ ".${var1}" = . ]
  155.         then
  156.             echo ${n} "Libary options (default:${LBOPT:-none}) ? ${c}"
  157.             read var1
  158.         fi
  159.  
  160.         [ ".${var1}" != . ] && LBOPT="${var1} ${var2} ${var3} ${var4} ${varr}"
  161.         ;;    
  162.  
  163.     7)
  164.         if [ ".${var1}" = . ]
  165.         then
  166.             echo "Some system needs extra defines see README"
  167.             echo ${n} "Special for your system (default:${EXTRA:-none}) ? ${c}"
  168.             read var1
  169.         fi
  170.  
  171.         [ ".${var1}" != . ] && EXTRA="${var1} ${var2} ${var3} ${var4} ${varr}"
  172.         ;;    
  173.  
  174.     8)
  175.         if [ ".${var1}" = . ]
  176.         then
  177.             echo ${n} "Number of register variable (default:${REGISTERS}) ? ${c}"
  178.             read var1 dummy
  179.         fi
  180.  
  181.         REGISTERS="${var1:-${REGISTERS}}"
  182.         ;;
  183.  
  184.     9)
  185.         if [ ".${var1}" = . ]
  186.         then
  187.             echo ${n} "Symbolic links (default:${LSTAT}) ? ${c}"
  188.             read var1 dummy
  189.         fi
  190.  
  191.         case "${var1:-${DIRENT}}" in
  192.         y|Y|yes|YES) LSTAT=yes; ;;
  193.         *)             LSTAT=no; ;;
  194.         esac
  195.         ;;
  196.  
  197.     10)
  198.         if [ ".${var1}" = . ]
  199.         then
  200.             echo ${n} "Do your system support utime.h (default:${UTIME_H}) ? ${c}"
  201.             read var1 dummy
  202.         fi
  203.  
  204.         case "${var1:-${DIRENT}}" in
  205.         y|Y|yes|YES) UTIME_H=yes; ;;
  206.         *)             UTIME_H=no; ;;
  207.         esac
  208.         ;;
  209.  
  210.     11)
  211.         case "${var1}" in
  212.         dirent)
  213.             DIRENT=yes; SYSDIR=no;
  214.             ;;
  215.         sys/dir) 
  216.             DIRENT=no; SYSDIR=yes;
  217.             ;;
  218.         *)
  219.             echo ${n} "Do your system support dirent.h (default:${DIRENT}) ? ${c}"
  220.             read var1 dummy
  221.             case "${var1:-${DIRENT}}" in
  222.             y|Y|yes|YES) DIRENT=yes; SYSDIR=no; ;;
  223.             *)             DIRENT=no; SYSDIR=no; ;;
  224.             esac
  225.  
  226.             if [ ${DIRENT} = no ]
  227.             then
  228.                 echo ${n} "Do your system support sys/dir.h (default:${SYSDIR}) ? ${c}"
  229.                 read var1 dummy
  230.                 case "${var1:-${SYSDIR}}" in
  231.                 y|Y|yes|YES) DIRENT=no; SYSDIR=yes; ;;
  232.                 *)             DIRENT=no; SYSDIR=no; ;;
  233.                 esac
  234.             fi
  235.             ;;
  236.         esac
  237.         ;;
  238.  
  239.     12)
  240.         if [ ".${var1}" = . ]
  241.         then
  242.             echo "If your system don't need word allignment for words (like 80386)"
  243.             echo "compress can use this fact to by faster. If your are not sure type y"
  244.             echo ${n} "Must words start at a even address (default:${NOALLIGN}) ? ${c}"
  245.             read var1 var2 varr
  246.         fi
  247.  
  248.         if [ ".${var2}" = . ]
  249.         then
  250.             echo ${n} "Byteorder on your system (default:${BYTEORDER}) ? ${c}"
  251.             read var2 varr 
  252.         fi
  253.  
  254.         case "${var1}" in
  255.         n|no|N|NO)    var1=no; ;;
  256.         *)            var1=yes; ;;
  257.         esac
  258.  
  259.          NOALLIGN="${var1:-${NOALLIGN}}"
  260.          BYTEORDER="${var2:-${BYTEORDER}}"
  261.         ;;
  262.  
  263.     d|D)
  264.         echo "Testing the system to find out what kind of system we have."
  265.         BINDIR=/usr/bin
  266.         MANDIR=/usr/man/man1
  267.         DIRENT=no
  268.         SYSDIR=no
  269.         UTIME_H=no
  270.         IBUFSIZ=2048
  271.         OBUFSIZ=2048
  272.         USERMEM=0
  273.         REGISTERS=2
  274.         LSTAT=no
  275.         CCOPT='-O'
  276.         LBOPT=
  277.         EXTRA=
  278.         [ -f /usr/include/sys/dir.h ] && { SYSDIR=yes; }
  279.         [ -f /usr/include/dirent.h ] && { DIRENT=yes; }
  280.         [ -f /usr/include/utime.h ] && { UTIME_H=yes; }
  281.         [ -d /usr/local/bin ] && { BINDIR=/usr/local/bin; }
  282.         [ -d /usr/local/man ] && { BINDIR=/usr/local/man/man1; }
  283.         [ -f /usr/bin/compress ] && { BINDIR=/usr/bin; }
  284.     
  285.         if [ ".${CC}" = . ]
  286.         then
  287.             echo ${n} "Find compiler. Compiler is: ${c}"
  288.             echo 'main() {return 0;}' >/tmp/sh$$.c
  289.  
  290.             for cc in cc gcc
  291.             do
  292.                 if ${cc} -c /tmp/sh$$.c >/dev/null 2>&1
  293.                 then
  294.                     rm -f sh$$.o
  295.                     CC=${cc}
  296.                     echo ${CC}
  297.                     break
  298.                 fi
  299.             done
  300.  
  301.             if [ ".${CC}" = . ]
  302.             then
  303.                 echo "Can't file one of the standaard compilers. Give C Compiler name"
  304.                 echo ${n} "C Compiler : ${c}"
  305.                 read CC dummy
  306.             fi
  307.         fi
  308.  
  309.         echo ${n} "Test best buffer size: ${c}"
  310.         cat >/tmp/sh$$.c <<!
  311. #include <stdio.h>
  312.         main()
  313.             {
  314.                 int        size;
  315.     
  316.                 size = 1024;
  317. #ifdef BUFSIZ
  318.                 if (size < BUFSIZ)    size = BUFSIZ;
  319. #endif
  320.                 if (sizeof(int)<4)    size = 2048;
  321.                 printf("%d\n", size);
  322.                 return 0;
  323.             }
  324. !
  325.         ${CC} /tmp/sh$$.c && IBUFSIZ=`./a.out`
  326.         rm -f /tmp/sh$$.c a.out
  327.         OBUFSIZ=${IBUFSIZ}
  328.         echo "${IBUFSIZ}"
  329.  
  330.         echo ${n} "Test byte order of system: ${c}"
  331.         cat >/tmp/sh$$.c <<!
  332.         main()
  333.             {
  334.                 long    test;
  335.         extern    int        write();
  336.         
  337.                 test = 0x31323334L;
  338.                 write(1, (char *)&test, 4);
  339.                 return 0;
  340.             }
  341. !
  342.         ${CC} /tmp/sh$$.c && BYTEORDER=`./a.out`
  343.         BYTEORDER="${BYTEORDER:-0000}"
  344.         echo ${BYTEORDER}
  345.         rm -f /tmp/sh$$.c a.out
  346.  
  347.  
  348.         echo ${n} "Test word allignment. Must words be allign: ${c}"
  349.         cat >/tmp/sh$$.c <<!
  350.         sig() {exit(1);}
  351.         main()
  352.             {
  353.                 int        i;
  354.                 char    bfr1[6];
  355.                 char    bfr2[6];
  356.                 long    test;
  357.         extern    int        write();
  358.  
  359.                 for (i = 1 ; i <= 15 ; ++i)
  360.                     signal(i, sig);
  361.     
  362.                 bfr1[0]=' ';bfr1[1]='1';bfr1[2]='2';
  363.                 bfr1[3]='3';bfr1[4]='4';bfr1[5]=' ';
  364.                 bfr2[0]='X';bfr2[1]='X';bfr2[2]='X';
  365.                 bfr2[3]='X';bfr2[4]='X';bfr2[5]='X';
  366.  
  367.                 test = *(long *)(bfr1+1);
  368.                 *(long *)(bfr2+0) = test;
  369.     
  370.                 if (bfr2[0] == '1' && bfr2[1] == '2' && bfr2[2] == '3' &&
  371.                     bfr2[3] == '4' && bfr2[4] == 'X')
  372.                     write(1, "no", 2);
  373.  
  374.                 return 0;
  375.             }
  376. !
  377.         ${CC} /tmp/sh$$.c && NOALLIGN=`( ./a.out ) 2>/dev/null`
  378.         NOALLIGN="${NOALLIGN:-yes}"
  379.         echo ${NOALLIGN}
  380.         rm -f /tmp/sh$$.c a.out core
  381.  
  382.         echo ${n} "Test number of register vars. Registers var: ${c}"
  383.         cat >/tmp/sh$$.c <<!
  384.         main()
  385.             {
  386.                 long            l11;
  387.                 long            l12;
  388.                 long            l13;
  389.                 long            l1;
  390.                 register long    rl01; register long    rl02;
  391.                 register long    rl03; register long    rl04;
  392.                 register long    rl05; register long    rl06;
  393.                 register long    rl07; register long    rl08;
  394.                 register long    rl09; register long    rl10;
  395.                 register long    rl11; register long    rl12;
  396.                 register long    rl13; register long    rl14;
  397.                 register long    rl15; register long    rl16;
  398.                 register long    rl17; register long    rl18;
  399.                 register long    rl19; register long    rl20;
  400.                 long            l2;
  401.                 long            l22;
  402.                 long            l23;
  403.                 long            l24;
  404.  
  405.                 l1 = (char *)&l1-(char *)&l2;
  406.                 if (l1 < 0)    l1 = -l1;
  407.                 l1 = 21-(l1/sizeof(long));
  408.                 if (l1 > 0 && l1 < 21)
  409.                     printf("%ld", l1);
  410.                 exit(0);
  411.             }
  412. !
  413.         cc /tmp/sh$$.c && REGISTERS=`./a.out`
  414.         REGISTERS=${REGISTERS:-2};
  415.         echo ${REGISTERS}
  416.         rm -f a.out /tmp/sh$$.c
  417.  
  418.         echo ${n} "Test if errno is declared in errno.h: ${c}"
  419.         cat >/tmp/sh$$.c <<!
  420. #include    <stdio.h>
  421. #include    <errno.h>
  422.         main()
  423.             {
  424.                 return    errno;
  425.             }
  426. !
  427.         if cc /tmp/sh$$.c
  428.         then
  429.             echo "Yes"
  430.         else
  431.             echo "No"
  432.             EXTRA="${EXTRA} -DDEF_ERRNO=1"
  433.         fi
  434.  
  435.         rm -f a.out /tmp/sh$$.c
  436.  
  437.  
  438.         echo ${n} "Test if system support symbolic links? ${c}"
  439.         cat >/tmp/sh$$.c <<!
  440.         main()
  441.             {
  442.                 lstat(0, 0);
  443.             }
  444. !
  445.         LSTAT=no
  446.         ${CC} /tmp/sh$$.c >/dev/null 2>&1 && LSTAT=yes
  447.         echo "${LSTAT}"
  448.         rm -f a.out /tmp/sh$$.c
  449.  
  450.         echo ${n} "Test availble memory${c}"
  451.         for size in 75000 130000 230000 440000 800000
  452.         do
  453.             cat >/tmp/sh$$.c <<!
  454.             char    test[${size}+128000];
  455.     
  456.             extern    int                alarm();
  457.             extern    int                exit();
  458.             extern    int                signal();
  459.     
  460.             sig() {exit(1);}
  461.  
  462.             main()
  463.                 {
  464.                     register int    i;
  465.                     register long    j;
  466.     
  467.                     for (i = 1 ; i <= 15 ; ++i)
  468.                         signal(i, sig);        
  469.  
  470.                     alarm(2);
  471.     
  472.                     for (i = 0 ; i < 10 ; ++i)
  473.                         for (j = 0 ; j < sizeof(test) ; j+= 1024)
  474.                             test[j] = i;
  475.  
  476.                     alarm(0);
  477.                     return 0;
  478.                 }
  479. !
  480.             ${CC} /tmp/sh$$.c >/dev/null 2>&1 || break
  481.             ./a.out || break
  482.             rm a.out /tmp/sh$$.c
  483.             USERMEM=${size}
  484.             echo ${n} " ${size}${c}"
  485.         done
  486.  
  487.         rm a.out /tmp/sh$$.c
  488.  
  489.         echo ""
  490.  
  491.         if [ ${USERMEM} = 0 ]
  492.         then
  493.             echo ${n} "Memory size is 0, segmented processor: ${c}"
  494.             cat >/tmp/sh$$.c <<!
  495.             long htab0[8192];
  496.             long htab1[8192];
  497.             long htab2[8192];
  498.             long htab3[8192];
  499.             long htab4[8192];
  500.             long htab5[8192];
  501.             long htab6[8192];
  502.             long htab7[8192];
  503.             long htab8[8192];
  504.             short code0tab[16384];
  505.             short code1tab[16384];
  506.             short code2tab[16384];
  507.             short code3tab[16384];
  508.             short code4tab[16384];
  509.             main() {return 0;}
  510. !
  511.             rm -f ./a.out
  512.             if ${CC} /tmp/sh$$.c >/dev/null 2>&1 
  513.             then
  514.                 :
  515.             else
  516.                 opt="-Ml"
  517.  
  518.                 while [ ".${opt}" != . ]
  519.                 do
  520.                     if ${CC} ${opt} /tmp/sh$$.c >/dev/null 2>&1 
  521.                     then
  522.                         :
  523.                     else
  524.                         CCOPT="${CCOPT} ${opt}"
  525.                         break
  526.                     fi
  527.  
  528.                     echo ${n} "Large model compile option: ${c}"
  529.                     read opt dummy
  530.                 done
  531.             fi
  532.  
  533.             if [ -f ./a.out ]
  534.             then
  535.                 if ./a.out
  536.                 then
  537.                     echo "Yes"
  538.                     MEMSIZE=0
  539.                     EXTRA="${EXTRA} -DMAXSEG_64K=1 -DBITS=16"
  540.                 else
  541.                     echo "No"
  542.                 fi
  543.             fi
  544.  
  545.             rm ./a.out /tmp/sh$$.c
  546.         fi
  547.  
  548.         DEFINED=yes
  549.         echo ""
  550.         echo "I have now create the default options for compiling compress ${version}"
  551.     ;;
  552.  
  553.     c|C)
  554.         options="${CCOPT} -o compress"
  555.         [ "${DIRENT}" = yes ] && options="${options} -DDIRENT=1"
  556.         [ "${SYSDIR}" = yes ] && options="${options} -DSYSDIR=1"
  557.         [ "${LSTAT}" != no  ] && options="${options} -DLSTAT=1"
  558.         [ "${UTIME_H}" != no  ] && options="${options} -DUTIME_H=1"
  559.         options="${options} -DUSERMEM=${USERMEM}"
  560.         options="${options} -DREGISTERS=${REGISTERS}"
  561.         options="${options} -DIBUFSIZ=${IBUFSIZ} -DOBUFSIZ=${OBUFSIZ}"
  562.         options="${options} -DBYTEORDER=${BYTEORDER}"
  563.         [ "${NOALLIGN}" = no ] && options="${options} -DNOALLIGN=1"
  564.         options="${options} ${EXTRA}"
  565.  
  566.         echo ""
  567.         echo "Compiling compress ${version}"
  568.  
  569.         echo ${CC} ${options} "-DCOMPILE_DATE=\"`date`\"" compress42.c ${LBOPT}
  570.  
  571.         if ${CC} ${options} "-DCOMPILE_DATE=\"`date`\"" compress42.c ${LBOPT}
  572.         then
  573.             echo ""
  574.             ./compress -V
  575.             echo ""
  576.             echo "Compress compiled, use 'i' to install compress in ${BINDIR}"
  577.         else
  578.             echo ""
  579.             echo "Error(s) in compilation"
  580.         fi
  581.         echo ""
  582.         echo ${n} "Press return to continue${c}"
  583.         read dummy
  584.         ;;
  585.  
  586.     s|S)
  587.         options="-O -S"
  588.         [ "${DIRENT}" = yes ] && options="${options} -DDIRENT=1"
  589.         [ "${SYSDIR}" = yes ] && options="${options} -DSYSDIR=1"
  590.         [ "${LSTAT}" != no  ] && options="${options} -DLSTAT=1"
  591.         [ "${UTIME_H}" != no  ] && options="${options} -DUTIME_H=1"
  592.         options="${options} -DUSERMEM=${USERMEM}"
  593.         options="${options} -DREGISTERS=${REGISTERS}"
  594.         options="${options} -DIBUFSIZ=${IBUFSIZ} -DOBUFSIZ=${OBUFSIZ}"
  595.         options="${options} -DBYTEORDER=${BYTEORDER}"
  596.         [ "${NOALLIGN}" = no ] && options="${options} -DNOALLIGN=1"
  597.         options="${options} ${EXTRA}"
  598.  
  599.         echo ""
  600.         echo "Compiling compress ${version}"
  601.  
  602.         echo ${CC} ${options} "-DCOMPILE_DATE=\"`date`\"" compress42.c 
  603.  
  604.         ${CC} ${options} "-DCOMPILE_DATE=\"`date`\"" compress42.c 
  605.         echo ""
  606.         echo ${n} "Press return to continue${c}"
  607.         read dummy
  608.         ;;
  609.  
  610.     t|T)
  611.         if [ ! -x ./compress ]
  612.         then
  613.             echo "Compile compress first before testing!"
  614.         else
  615.             if [ ".${var1}" = . ]
  616.             then
  617.                 echo "To test compress you need a test set. For a test set alle filein one"
  618.                 echo "directory are combined to one file with cpio and compress/decompressed"
  619.                 echo ${n} "Test directory [default:current]: ${c}"
  620.                 read var1 varr
  621.             fi
  622.  
  623.             if [ ! -d ${var1:-.} ]
  624.             then
  625.                 echo "$var1: no directory"
  626.             else
  627.                 var1=`cd ${var1:-.};pwd`
  628.                 find ${var1} -type f -print |
  629.                     ( while read fn ; do [ -r ${fn} ] && echo ${fn} ; done ) |
  630.                     sort >/tmp/sh$$.fi
  631.  
  632.                 (
  633.                     echo "==============================================================================="
  634.                     echo "Directory: ${var1:-/}"
  635.                     echo "./compress -V"
  636.                     ./compress -V
  637.  
  638.                     if [ -x ${BINDIR}/compress ]
  639.                     then
  640.                         old=${var2:-${BINDIR}/compress}
  641.                         set -- ./compress ${old} \
  642.                                 ${old} ./compress \
  643.                                 ./compress ./compress \
  644.                                 ${old} ${old}
  645.  
  646.                         echo "${old} -V"
  647.                         ${old} -V </dev/null dummy-file
  648.                     else
  649.                         set -- ./compress ./compress
  650.                     fi
  651.  
  652.                     while [ $# != 0 ]
  653.                     do
  654.                         echo "---------------- $1 -> $2 ----------------"
  655.                         if [ -x /sbin/sync ] ;    then /sbin/sync
  656.                                                 else sync ; fi
  657.  
  658.                         sleep 1
  659.  
  660.                         cpio -o </tmp/sh$$.fi |
  661.                             ( time $1 -v 2>/tmp/sh$$.tm1 ) |
  662.                             ( time $2 -d 2>/tmp/sh$$.tm2 ) |
  663.                             ( cpio -ivt >/tmp/sh$$.fo )
  664.         
  665.                         awk </tmp/sh$$.fo '{print $8}'  >/tmp/sh$$.foo
  666.     
  667.                         if cmp /tmp/sh$$.fi /tmp/sh$$.foo
  668.                         then
  669.                             :
  670.                         else
  671.                             echo ------ ERROR
  672.                             diff /tmp/sh$$.fi /tmp/sh$$.foo
  673.                         fi
  674.  
  675.                         echo "---------------"
  676.                         echo "compress   $1("`cat /tmp/sh$$.tm1`")"
  677.                         echo "decompress $2("`cat /tmp/sh$$.tm2`")"
  678.                         shift 2
  679.                     done
  680.                 ) 2>&1 | tee /tmp/sh$$.log
  681.  
  682.                 cat /tmp/sh$$.log >>comp.log && rm /tmp/sh$$.log
  683.             fi
  684.  
  685.             echo ""
  686.         fi
  687.  
  688.         echo ${n} "Press return to continue${c}"
  689.         read dummy
  690.         ;;
  691.     i|I)
  692.         if [ ".${var1}" = . ]
  693.         then
  694.             echo ${n} "Install compress with user ? (default current user) ? ${c}"
  695.             read var1 dummy
  696.         fi
  697.  
  698.         pwd=`pwd`
  699.  
  700.         ( cat - <<!
  701.             set -x
  702.  
  703.             cd ${pwd}
  704.  
  705.             [ -f ${BINDIR}/compress ] &&
  706.                 { rm -f ${BINDIR}/compress.old ;
  707.                   mv ${BINDIR}/compress ${BINDIR}/compress.old || exit 1; }
  708.  
  709.             rm -f ${BINDIR}/uncompress ${BINDIR}/zcat || exit 1
  710.  
  711.             cp compress ${BINDIR}/compress || exit 1
  712.             strip ${BINDIR}/compress
  713.             rm -f ${BINDIR}/uncompress || exit 1
  714.             ln ${BINDIR}/compress ${BINDIR}/uncompress || exit 1
  715.             rm -f  ${BINDIR}/zcat || exit 1
  716.             ln -f ${BINDIR}/compress ${BINDIR}/zcat || exit 1
  717.             cp zcmp zdiff zmore ${BINDIR}/. || exit 1
  718.             chmod 0755 ${BINDIR}/compress ${BINDIR}/zcmp ${BINDIR}/zdiff \
  719.                        ${BINDIR}/zmore || exit 1
  720.             cp compress.1 zcmp.1 zmore.1 ${MANDIR}/. || exit 1
  721.             chmod 0644 ${MANDIR}/compress.1 ${MANDIR}/zcmp.1 \
  722.                        ${MANDIR}/zmore.1 || exit 1
  723.  
  724.             if [ ".${var1}" != . ]
  725.             then
  726.                 chown ${var1} ${BINDIR}/compress ${BINDIR}/zcmp \
  727.                               ${BINDIR}/zdiff ${BINDIR}/zmore \
  728.                               ${MANDIR}/compress.1 ${MANDIR}/zcmp.1 \
  729.                                  ${MANDIR}/zmore.1 
  730.             fi
  731. !
  732.         ) | (
  733.             if [ ".${var1}" = . ] ;    then sh 
  734.                                     else su - ${var1} -c sh ; fi
  735.         )
  736.  
  737.         echo ""
  738.         echo ${n} "Press return to continue${c}"
  739.         read dummy
  740.         ;;
  741.  
  742.     genmake)
  743.         options=
  744.         [ "${DIRENT}" = yes ] && options="${options} -DDIRENT=1"
  745.         [ "${SYSDIR}" = yes ] && options="${options} -DSYSDIR=1"
  746.         [ "${LSTAT}" != no  ] && options="${options} -DLSTAT=1"
  747.         [ "${UTIME_H}" != no  ] && options="${options} -DUTIME_H=1"
  748.         options="${options} -DUSERMEM=${USERMEM}"
  749.         options="${options} -DREGISTERS=${REGISTERS}"
  750.         options="${options} -DIBUFSIZ=${IBUFSIZ} -DOBUFSIZ=${OBUFSIZ}"
  751.         options="${options} -DBYTEORDER=${BYTEORDER}"
  752.         [ "${NOALLIGN}" = no ] && options="${options} -DNOALLIGN=1"
  753.         options="${options} ${EXTRA}"
  754.  
  755.         cat - <<! >Makefile
  756. # Makefile generated by build.
  757.  
  758. # C complier
  759. CC=${CC}
  760.  
  761. # Install directory for binarys
  762. BINDIR=${BINDIR}
  763.  
  764. # Install directory for manual
  765. MANDIR=${MANDIR}
  766.  
  767. # compiler options:
  768. # options is a collection of:
  769. #
  770. #    -DAMIGA=1                    Amiga support.
  771. #    -DNOFUNCDEF=1                Disable libary function definitions in
  772. #                                compress42.c
  773. #    -DDIRENT=1                    Use dirent.h
  774. #    -DSYSDIR=1                    Use sys/dir.h
  775. #    -DLSTAT=1                    Use lstat for finding symlinks.
  776. #    -DUTIME_H=1                    Use utime.h
  777. #    -DUSERMEM=<size>            Availble memory for compress (default 800k).
  778. #    -DREGISTERS=<nbr>            Number of registers (default 2).
  779. #    -DIBUFSIZ=<size>            Input buffer size (default BUFSIZ).
  780. #    -DOBUFSIZ=<size>            Output buffer size (default BUFSIZ)
  781. #    -DBYTEORDER=<order>            Byte order (default: unknown).
  782. #    -DNOALLIGN=1                Data word allignment (default: yes).
  783. #    -DDEF_ERRNO=1                Define error (not defined in errno.h).
  784. #    -DMAXSEG_64K=1 -BITS=16        Support segment processsor like 80286.
  785. #
  786. options=${options}
  787.  
  788. # libary options
  789. LBOPT=${LBOPT}
  790.  
  791.  
  792. compress:    Makefile compress42.c patchlevel.h
  793.     $(CC) -o compress $(options) "-DCOMPILE_DATE=\"\`date\`\"" compress42.c $(LBOPT)
  794.  
  795. install:    compress
  796.         [ -f \$(BINDIR)/compress ] && \\
  797.             { rm -f \$(BINDIR)/compress.old ; \\
  798.               mv \$(BINDIR)/compress \$(BINDIR)/compress.old ; }
  799.         rm -f \$(BINDIR)/uncompress \$(BINDIR)/zcat
  800.         cp compress \$(BINDIR)/compress
  801.         strip \$(BINDIR)/compress
  802.         rm -f \$(BINDIR)/uncompress
  803.         ln \$(BINDIR)/compress \$(BINDIR)/uncompress
  804.         rm -f \$(BINDIR)/zcat
  805.         ln -f \$(BINDIR)/compress \$(BINDIR)/zcat
  806.         cp zcmp zdiff zmore \$(BINDIR)/.
  807.         chmod 0755 \$(BINDIR)/compress \$(BINDIR)/zcmp \$(BINDIR)/zdiff \$(BINDIR)/zmore
  808.         cp compress.1 zcmp.1 zmore.1 \$(MANDIR)/.
  809.         chmod 0644 \$(MANDIR)/compress.1 \$(MANDIR)/zcmp.1 \$(MANDIR)/zmore.1
  810.  
  811. cleanup:
  812.         rm -f compress compress.def comp.log
  813. !
  814.         ;;
  815.  
  816.     mkshar)
  817.         xshar -sc -opart -l64 MANIFEST Acknowleds zmore Changes compress.1 \
  818.             zcmp zmore.1 README LZW.INFO zcmp.1 zdiff build Makefile.def \
  819.             compress42.c patchlevel.h
  820.         ;;
  821.  
  822.     mktar)
  823.         rm -f comp.tar
  824.         tar cvf comp.tar MANIFEST Acknowleds zmore Changes compress.1 \
  825.             zcmp zmore.1 README LZW.INFO zcmp.1 zdiff build Makefile.def \
  826.             compress42.c patchlevel.h
  827.         ;;
  828.  
  829.     cleanup)
  830.         rm -f compress compress.def comp.log
  831.         exit 0
  832.         ;;
  833.  
  834.     q|Q)
  835.         exit 0
  836.         ;;
  837.     *)
  838.         echo "                                      Unknown choice ${choice}"
  839.         sleep 2
  840.         ;;
  841.     esac
  842. done
  843.