home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / uucp / duucp-1.17 / AU-117b4-src.lha / src / unix / compress.c next >
Encoding:
C/C++ Source or Header  |  1993-12-27  |  5.2 KB  |  287 lines
  1. /*
  2.  *  COMPRESS.C
  3.  *
  4.  *  Compress/UNCompress/ZCat
  5.  */
  6.  
  7. #include <exec/types.h>
  8. #include <exec/nodes.h>
  9. #include <exec/lists.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include "config.h"
  14. #include "version.h"
  15. #include "OwnDevUnit.h"
  16.  
  17. struct Library *OwnDevUnitBase = NULL;
  18. typedef struct List List;
  19. typedef struct Node Node;
  20.  
  21. List    FileList;
  22. short    CompressOpt;
  23. short    VerboseOpt;
  24. short    ForceOpt;
  25. short    ZCatOpt;
  26. short    Bits = 14;
  27.  
  28. IDENT (".04");
  29.  
  30. Node *MakeNode (char *, char);
  31. int suffix (char *, char *);
  32.  
  33. int
  34.     _bufsiz = 8192;
  35.  
  36. void
  37. myexit (void)
  38. {
  39.     if (OwnDevUnitBase) {
  40.         CloseLibrary (OwnDevUnitBase);
  41.         OwnDevUnitBase = NULL;
  42.     }
  43. }
  44.  
  45. int
  46. main (int ac, char **av)
  47. {
  48.     int error = 0;
  49.  
  50.     NewList(&FileList);
  51.  
  52.     {
  53.     char *ptr;
  54.  
  55.     if (ptr = av[0]) {
  56.         char *p2;
  57.  
  58.         if (p2 = strrchr(ptr, '/'))
  59.         ptr = p2 + 1;
  60.  
  61.         switch(ptr[0]) {
  62.         case 'u':
  63.         case 'U':
  64.         CompressOpt = 0;
  65.         break;
  66.         case 'z':
  67.         case 'Z':
  68.         ZCatOpt = 1;
  69.         CompressOpt = 0;
  70.         break;
  71.         default:
  72.         CompressOpt = 1;
  73.         break;
  74.         }
  75.     }
  76.     }
  77.  
  78.     {
  79.     short i;
  80.     char *ptr;
  81.  
  82.     for (i = 1; i < ac; ++i) {
  83.         ptr = av[i];
  84.  
  85.         if (*ptr != '-') {
  86.         AddTail(&FileList, MakeNode(ptr, 0));
  87.         continue;
  88.         }
  89.         ptr += 2;
  90.         switch(ptr[-1]) {
  91.         case 'f':       /*  force compression   */
  92.         ForceOpt = 1;
  93.         break;
  94.         case 'c':       /*  write to stdout     */
  95.         ZCatOpt = 1;
  96.         break;
  97.         case 'b':       /*  bits, default 14    */
  98.         Bits = strtol(((*ptr) ? ptr : av[++i]), NULL, 0);
  99.         if (Bits < 12 || Bits > 16) {
  100.             fprintf(stderr, "Illegal number of bits specified: %d\n", Bits);
  101.             exit(20);
  102.         }
  103.         break;
  104.         case 'v':
  105.         fprintf(stderr, "AmigaUUCP Compress V5.1.A01\n");
  106.         VerboseOpt = 1;
  107.         break;
  108.         case 'd':       /*  decompress          */
  109.         CompressOpt = 0;
  110.         break;
  111.         case 'V':
  112.         fprintf(stderr, "AmigaUUCP Compress V5.1.A01\n");
  113.         break;
  114.         }
  115.     }
  116.     }
  117.  
  118.     atexit(myexit);
  119.     OwnDevUnitBase = OpenLibrary (ODU_NAME, 0);
  120.     if (OwnDevUnitBase == 0) {
  121.     fprintf (stderr, "Unable to open " ODU_NAME "\n");
  122.     exit (20);
  123.     }
  124.     /*
  125.      *    Run through file list.    If no files specified used stdin
  126.      */
  127.  
  128.     if (FileList.lh_Head == (Node *)&FileList.lh_Tail) {
  129.     AddTail(&FileList, MakeNode("", 1));
  130.     }
  131.  
  132.     {
  133.     Node *node;
  134.     FILE *fi;
  135.     FILE *fo;
  136.  
  137.     while (node = RemHead(&FileList)) {
  138.         char *srcFileName = malloc(strlen(node->ln_Name) + 16);
  139.         char *dstFileName = malloc(strlen(node->ln_Name) + 16);
  140.         long fi_size;
  141.         long fo_size;
  142.         int r = -1;
  143.         short stdinOpt = 0;
  144.         short destCreate = 0;
  145.         short verboseOpt = VerboseOpt;
  146.  
  147.  
  148.         /*
  149.          *    Handle compress/decompress from stdin.    Output is to
  150.          *    stdout.
  151.          */
  152.  
  153.         if (node->ln_Type == 1) {
  154.         stdinOpt = 1;
  155.         ZCatOpt = 1;
  156.  
  157.         strcpy(srcFileName, "<stdin>");
  158.         strcpy(dstFileName, "<stdout>");
  159.         } else {
  160.         /*
  161.          *  Add .Z suffix to srcFileName, remove .Z suffix from
  162.          *  dstFileName.  If compressing, exchange the pointers
  163.          */
  164.  
  165.         strcpy(srcFileName, node->ln_Name);
  166.         strcpy(dstFileName, node->ln_Name);
  167.  
  168.         if (suffix(srcFileName, ".Z") != 0)
  169.             strcat(srcFileName, ".Z");
  170.  
  171.         if (suffix(dstFileName, ".Z") == 0)
  172.             dstFileName[strlen(dstFileName)-2] = 0;
  173.         }
  174.  
  175.         /*
  176.          *    Exchange source/destination if compressing
  177.          */
  178.  
  179.         if (stdinOpt == 0 && CompressOpt) {
  180.         char *tmp = srcFileName;
  181.         srcFileName = dstFileName;
  182.         dstFileName = tmp;
  183.         }
  184.  
  185.         if (VerboseOpt) {
  186.         fprintf(stderr, "%-15s -> %-15s ", srcFileName, dstFileName);
  187.         fflush(stderr);
  188.         }
  189.  
  190.         if (stdinOpt)
  191.         fi = stdin;
  192.         else
  193.         fi = fopen(srcFileName, "r");
  194.  
  195.         if (fi) {
  196.         if (ZCatOpt)
  197.             fo = stdout;
  198.         else
  199.             fo = fopen(dstFileName, "w");
  200.  
  201.         if (fo) {
  202.             destCreate = 1;
  203.  
  204.             if (CompressOpt)
  205.             r = unix_compress_from_fp(fi, fo, Bits);
  206.             else
  207.             r = unix_uncompress_to_fp(fi, fo, &Bits);
  208.             fo_size = ftell(fo);
  209.             if (ZCatOpt == 0)
  210.             fclose(fo);
  211.         } else {
  212.             fprintf(stderr, "(can't open %s)", dstFileName);
  213.             verboseOpt = 1;
  214.         }
  215.         fi_size = ftell(fi);
  216.         if (stdinOpt == 0)
  217.             fclose(fi);
  218.         } else {
  219.         fprintf(stderr, "(can't open %s)", srcFileName);
  220.         verboseOpt = 1;
  221.         }
  222.  
  223.         /*
  224.          *    If compressing and not ForceOpt, check result size
  225.          */
  226.  
  227.         if (r == 0) {
  228.         if (VerboseOpt) {
  229.             long factor = 10000 - fo_size * 10000 / fi_size;
  230.  
  231.             fprintf(stderr, "%6d->%-6d B=%d %d.%02d%% ",
  232.             fi_size,
  233.             fo_size,
  234.             Bits,
  235.             factor / 100,
  236.             (factor < 0) ? -(factor % 100) : (factor % 100)
  237.             );
  238.         }
  239.         if (ZCatOpt == 0 && CompressOpt && ForceOpt == 0 && fi_size < fo_size) {
  240.             if (VerboseOpt)
  241.             fprintf(stderr, "(did not comp)");
  242.             remove(dstFileName);
  243.         } else if (ZCatOpt == 0) {
  244.             remove(srcFileName);
  245.         }
  246.         } else if (ZCatOpt == 0) {
  247.         if (destCreate)
  248.             remove(dstFileName);
  249.         }
  250.         if (verboseOpt)
  251.         fprintf(stderr, "\n");
  252.  
  253.         free(dstFileName);
  254.         free(srcFileName);
  255.         free(node);
  256.         if (r)
  257.         error = 1;
  258.     }
  259.     }
  260.     return(error);
  261. }
  262.  
  263. Node *
  264. MakeNode(char *str, char type)
  265. {
  266.     Node *node;
  267.  
  268.     if (node = malloc(sizeof(Node))) {
  269.     node->ln_Name = str;
  270.     node->ln_Type = type;
  271.     } else {
  272.     fprintf(stderr, "no memory!\n");
  273.     exit(20);
  274.     }
  275.     return(node);
  276. }
  277.  
  278. int
  279. suffix(char *str, char *suf)
  280. {
  281.     short l1 = strlen(str);
  282.     short l2 = strlen(suf);
  283.  
  284.     if (l1 < l2)
  285.     return(-1);
  286. }
  287.