pack.c

   1
   2 /*
   3  * pack/unpack archive files
   4  *
   5  * $Header: pack.c 1.5 95/08/01 $
   6  * $Log:        pack.c,v $
   7  * Revision 1.5  95/08/01  xx:xx:xx  BB
   8  * Fixed for Borland C/C++
   9  *
  10  * Revision 1.4  92/12/07  17:19:29  duplain
  11  * reformatted source.
  12  *
  13  * Revision 1.3  92/11/09  14:48:36  duplain
  14  * Added putc_init() to re-initialise variables.
  15  *
  16  * Revision 1.2  92/10/01  11:22:35  duplain
  17  * Added check for EOF.
  18  *
  19  * Revision 1.1  92/09/29  18:02:25  duplain
  20  * Initial revision
  21  *
  22  */
  23
  24 #include <stdio.h>
  25 #include "spark.h"
  26 #include "main.h"
  27 #include "crc.h"
  28 #include "garble.h"
  29
  30 /* BB changed next line because of conflict with Borland's io.h */
  31
  32 /* #include "io.h" */
  33 #include "nsparkio.h"
  34
  35 #include "pack.h"
  36
  37 static short running;
  38 static Word complen;
  39
  40
  41 void
  42 putc_init()
  43 {
  44         running = 0;
  45 }
  46
  47 /*
  48  * write run-length encoding to output file
  49  */
  50
  51 void
  52 putc_ncr(FILE *ofp, Byte byte)
  53 {
  54         static Byte prevbyte;
  55
  56         if (running)
  57         {
  58                 if (!byte)
  59                 {                                               /* means write RUNMARK to output */
  60                         calccrc(RUNMARK);
  61                         if (!testing)
  62                                 write_byte(ofp, RUNMARK);
  63                 }
  64                 else
  65                 {
  66                         /* BB changed next line */
  67                         /* Borland C++ is `a bit fuzzy' about next line */
  68                         /*  while (--byte) { */
  69 #ifdef __MSDOS__
  70                         while (--byte != 0)
  71                         {
  72 #else
  73                         while (--byte)
  74                         {
  75 #endif
  76                                 calccrc(prevbyte);
  77                                 if (!testing)
  78                                         write_byte(ofp, prevbyte);
  79                         }
  80                 }
  81                 running = 0;
  82         }
  83         else if (byte == RUNMARK)
  84         {
  85                 running++;
  86         }
  87         else
  88         {
  89                 prevbyte = byte;                /* save in case next byte is RUNMARK */
  90                 calccrc(byte);
  91                 if (!testing)
  92                         write_byte(ofp, byte);
  93         }
  94 }
  95
  96 Status
  97 unpack(Header *header, FILE *ifp, FILE *ofp)
  98 {
  99         register Word len = header->complen;
 100
 101     init_garble();
 102
 103         crc = 0;
 104         putc_init();
 105         while (len--)
 106         {
 107                 if (check_stream(ifp) != FNOERR)
 108                         break;
 109                 putc_ncr(ofp, ungarble(read_byte(ifp)));
 110         }
 111
 112         if (check_stream(ifp) == FRWERR)
 113                 return (RERR);
 114         if (!testing && check_stream(ofp) == FRWERR)
 115                 return (WERR);
 116         if ((Halfword) crc != header->crc)
 117                 return (CRCERR);
 118         if (testing)
 119                 printf("OK (packed)");
 120         else
 121                 printf("unpacked");
 122         return (NOERR);
 123 }
 124
 125 void
 126 write_ncr(FILE *ofp, Byte byte, int bytecount)
 127 {
 128         int i;
 129
 130         if (bytecount > 1)
 131         {
 132                 fputc((int)garble(byte), ofp);
 133                 fputc((int)garble(RUNMARK), ofp);
 134                 fputc((int)garble(bytecount), ofp);
 135                 complen += 3;
 136                 for (i = 0; i < bytecount; i++)
 137                 {
 138                         calccrc(byte);
 139                 }
 140         }
 141         else
 142         {
 143                 if (byte == RUNMARK)
 144                 {
 145                         calccrc(RUNMARK);
 146                         fputc((int)garble(RUNMARK), ofp);
 147                         fputc(garble(0), ofp);
 148                         complen += 2;
 149                 }
 150                 else
 151                 {
 152                         calccrc(byte);
 153                         fputc((int)garble(byte), ofp);
 154                         complen += 1;
 155                 }
 156         }
 157 }
 158
 159 Status
 160 pack(Header *header, FILE *ifp, FILE *ofp)
 161 {
 162         register Word len = header->origlen;
 163         Byte prevbyte = '\0', byte;
 164         int bytecount = 0;
 165
 166     init_garble();
 167
 168         complen = 0;
 169         crc = 0;
 170         prevbyte = read_byte(ifp);
 171         len--;
 172         bytecount = 1;
 173         while (len--)
 174         {
 175                 byte = read_byte(ifp);
 176                 if(prevbyte == RUNMARK)
 177                 {
 178                         write_ncr(ofp, prevbyte, 1);
 179                         bytecount = 1;
 180                 }
 181                 else if (byte == prevbyte && bytecount < 254)
 182                 {
 183                         bytecount++;
 184                 }
 185                 else
 186                 {
 187                         write_ncr(ofp, prevbyte, bytecount);
 188                         bytecount = 1;
 189                 }
 190                 prevbyte = byte;
 191                 if (check_stream(ifp) != FNOERR)
 192                         break;
 193         }
 194         write_ncr(ofp, prevbyte, bytecount);
 195
 196         if (check_stream(ifp) == FRWERR)
 197                 return (RERR);
 198         if (!testing && check_stream(ofp) == FRWERR)
 199                 return (WERR);
 200         if (testing)
 201                 printf("OK (packed)");
 202         else
 203                 printf("packed");
 204
 205         header->crc = (Halfword) crc;
 206         header->complen = complen;
 207
 208         return (NOERR);
 209 }