i386/rcz/rcz_compress_file.c

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
   7  *
   8  * This file contains Original Code and/or Modifications of Original Code
   9  * as defined in and that are subject to the Apple Public Source License
  10  * Version 2.0 (the 'License'). You may not use this file except in
  11  * compliance with the License. Please obtain a copy of the License at
  12  * http://www.opensource.apple.com/apsl/ and read it before using this
  13  * file.
  14  *
  15  * The Original Code and all software distributed under the License are
  16  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  17  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  18  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  20  * Please see the License for the specific language governing rights and
  21  * limitations under the License.
  22  *
  23  * @APPLE_LICENSE_HEADER_END@
  24  */
  25 /*
  26    Library: compressor for executable files.
  27
  28    R. E. Crandall, July 1995
  29
  30    Copyright 1995 NeXT Computer, Inc.
  31    All rights reserved.
  32
  33  */
  34
  35 #import "rcz_common.h"
  36
  37 static unsigned short que[QLEN];
  38
  39 unsigned int
  40 rcz_compress_file(
  41     int in_fd,
  42     unsigned int inbytes,
  43     unsigned char *out
  44 )
  45 /* Returns actual number of bytes emitted as compressed stream 'out.' */
  46 {
  47     unsigned int c, ct, j, jmatch, jabove, match;
  48     unsigned int data[32], version;
  49     unsigned int word, token, tokenct, total;
  50     unsigned char *outorigin = out;
  51
  52 /* First, put version number into stream. */
  53     *out++ = (METHOD_17_JUL_95>>24) & 0xff;
  54     *out++ = (METHOD_17_JUL_95>>16) & 0xff;
  55     *out++ = (METHOD_17_JUL_95>>8) & 0xff;
  56     *out++ = (METHOD_17_JUL_95) & 0xff;
  57 /* Next, put the initial size into stream. */
  58     *out++ = (inbytes>>24) & 0xff;
  59     *out++ = (inbytes>>16) & 0xff;
  60     *out++ = (inbytes>>8) & 0xff;
  61     *out++ = (inbytes) & 0xff;
  62
  63     for(ct=0; ct < QLEN; ct++) que[ct] = ct;
  64     word = token = tokenct = 0;
  65     for(ct = 0; ct < inbytes; ct++) {
  66         /* Next, update bucket-brigade register. */
  67           word = (word << 8) | (*in++);
  68           if(ct % 2 == 1) {
  69                 word &= 0xffff;
  70                 match = 0;
  71                 for(j=0; j < QLEN; j++) {
  72                         if(que[j] == word) {
  73                                 match = 1;
  74                                 jmatch = j;
  75                                 break;
  76                         }
  77                 }
  78                 token = (token<<1) | match;
  79                 if(match) { /* 16-bit symbol is in queue. */
  80                         c = que[jmatch];
  81                         jabove = (F1 * jmatch) >> 4;
  82                         for(j = jmatch; j > jabove; j--) {
  83                              que[j] = que[j-1];
  84                         }
  85                         que[jabove] = c;
  86                         data[tokenct++] = jmatch;
  87                 } else {   /* 16-bit symbol is not in queue. */
  88                     for(j=QLEN-1; j > ABOVE; j--) {
  89                         que[j] = que[j-1];
  90                     }
  91                     que[ABOVE] = word;
  92                     data[tokenct++] = word;
  93                 }
  94                 if(tokenct == 32) {  /* Unload tokens and data. */
  95                     *out++ = (token>>24) & 0xff;
  96                     *out++ = (token>>16) & 0xff;
  97                     *out++ = (token>>8) & 0xff;
  98                     *out++ = (token) & 0xff;
  99                     c = (1<<31);
 100                     for(j = 0; j < tokenct; j++) {
 101                         if(token & c) *out++ = data[j] & 0xff;
 102                            else {
 103                                *out++ = (data[j] >> 8) & 0xff;
 104                                *out++ = (data[j]) & 0xff;
 105                            }
 106                         c >>= 1;
 107                     }
 108                     token = tokenct = 0;
 109                 }
 110           }
 111     }
 112     if(tokenct > 0) { /* Flush final token and data. */
 113         token <<= (32-tokenct);
 114         *out++ = (token>>24) & 0xff;
 115         *out++ = (token>>16) & 0xff;
 116         *out++ = (token>>8) & 0xff;
 117         *out++ = (token) & 0xff;
 118         c = (1<<31);
 119         for(j = 0; j < tokenct; j++) {
 120                 if(token & c) *out++ = data[j] & 0xff;
 121                    else {
 122                        *out++ = (data[j] >> 8) & 0xff;
 123                        *out++ = (data[j]) & 0xff;
 124                    }
 125                 c >>= 1;
 126         }
 127     }
 128     if(ct % 2 == 1) *out++ = (word) & 0xff;
 129     return((int)(out-outorigin));
 130 }