gen/rcz/rcz_compress_mem.c

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
   7  * Reserved.  This file contains Original Code and/or Modifications of
   8  * Original Code as defined in and that are subject to the Apple Public
   9  * Source License Version 1.1 (the "License").  You may not use this file
  10  * except in compliance with the License.  Please obtain a copy of the
  11  * License at http://www.apple.com/publicsource and read it before using
  12  * this file.
  13  *
  14  * The Original Code and all software distributed under the License are
  15  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  16  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  17  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT.  Please see the
  19  * License for the specific language governing rights and limitations
  20  * under the License.
  21  *
  22  * @APPLE_LICENSE_HEADER_END@
  23  */
  24 /*
  25    Library: compressor for executable files.
  26
  27    R. E. Crandall, July 1995
  28
  29    Copyright 1995 NeXT Computer, Inc.
  30    All rights reserved.
  31
  32  */
  33
  34 #import "rcz_common.h"
  35
  36 static unsigned short que[QLEN];
  37
  38
  39 unsigned int
  40 rcz_compress_memory(
  41     unsigned char *in,
  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 }