/* compress.c */

#include "copyright.h"
#include "config.h"

#ifdef COMPRESS
#include <stdio.h>
#include "teeny.h"

/* Compression routines */
/*
 * -*-C-*-
 * 
 * Copyright (c) 1989, 1990 by David Applegate, James Aspnes, Timothy Freeman,
 * and Bennet Yee.
 * 
 * This material was developed by the above-mentioned authors. Permission to
 * copy this software, to redistribute it, and to use it for any purpose is
 * granted, subject to the following restrictions and understandings.
 * 
 * 1. Any copy made of this software must include this copyright notice in full.
 * 
 * 2. Users of this software agree to make their best efforts (a) to return to
 * the above-mentioned authors any improvements or extensions that they make,
 * so that these may be included in future releases; and (b) to inform the
 * authors of noteworthy uses of this software.
 * 
 * 3. All materials developed as a consequence of the use of this software shall
 * duly acknowledge such use, in accordance with the usual standards of
 * acknowledging credit in academic research.
 * 
 * 4. The authors have made no warrantee or representation that the operation of
 * this software will be error-free, and the authors are under no obligation
 * to provide any services, by way of maintenance, update, or otherwise.
 * 
 * 5. In conjunction with products arising from the use of this material, there
 * shall be no use of the names of the authors, of Carnegie-Mellon
 * University, nor of any adaptation thereof in any advertising, promotional,
 * or sales literature without prior written consent from the authors, and
 * Carnegie-Mellon University in each case.
 */


/* These use a pathetically simple encoding that takes advantage of the */
/* eighth bit on a char; if you are using an international character set, */
/* they may need substantial patching. */

#define BUFFER_LEN 16384	/* nice big buffer */

#define TOKEN_BIT 0x80		/* if on, it's a token */
#define TOKEN_MASK 0x7f		/* for stripping out token value */
#define NUM_TOKENS (128)
#define MAX_CHAR (128)

/* Top 128 bigrams in the CMU TinyMUD database as of 2/13/90 */
static char    *tokens[NUM_TOKENS] = {
  "e ", " t", "th", "he", "s ", " a", "ou", "in",
  "t ", " s", "er", "d ", "re", "an", "n ", " i",
  " o", "es", "st", "to", "or", "nd", "o ", "ar",
  "r ", ", ", "on", " b", "ea", "it", "u ", " w",
  "ng", "le", "is", "te", "en", "at", " c", "y ",
  "ro", " f", "oo", "al", ". ", "a ", " d", "ut",
  " h", "se", "nt", "ll", "g ", "yo", " l", " y",
  " p", "ve", "f ", "as", "om", "of", "ha", "ed",
  "h ", "hi", " r", "lo", "Yo", " m", "ne", "l ",
  "li", "de", "el", "ta", "wa", "ri", "ee", "ti",
  "no", "do", "Th", " e", "ck", "ur", "ow", "la",
  "ac", "et", "me", "il", " g", "ra", "co", "ch",
  "ma", "un", "so", "rt", "ai", "ce", "ic", "be",
  " n", "k ", "ge", "ot", "si", "pe", "tr", "wi",
  "e.", "ca", "rs", "ly", "ad", "we", "bo", "ho",
  "ir", "fo", "ke", "us", "m ", " T", "di", ".."
};

static char     token_table[MAX_CHAR][MAX_CHAR];
static int      table_initialized = 0;
char           *compress();
char           *uncompress();

static void     init_compress()
{
  int             i;
  int             j;

  for (i = 0; i < MAX_CHAR; i++) {
    for (j = 0; j < MAX_CHAR; j++) {
      token_table[i][j] = 0;
    }
  }

  for (i = 0; i < NUM_TOKENS; i++) {
    token_table[tokens[i][0]][tokens[i][1]] = i | TOKEN_BIT;
  }

  table_initialized = 1;
}

char           *
                compress(s)
  char           *s;
{
  static char     buf[BUFFER_LEN];
  char           *to;
  char            token;

  if (!table_initialized)
    init_compress();

  if (s == NULL)
    return (char *) NULL;	/* don't compress NULL */

  /* tokenize the first characters */
  for (to = buf; s[0] && s[1]; to++) {
    if (token = token_table[s[0]][s[1]]) {
      *to = token;
      s += 2;
    } else {
      *to = s[0];
      s++;
    }
  }

  /* copy the last character (if any) and null */
  while (*to++ = *s++);

  return buf;
}

char           *
                uncompress(s)
  char           *s;
{
  static char     buf[BUFFER_LEN];
  char           *to;
  char           *token;

  if (s == NULL)
    return (char *) NULL;	/* don't uncompress NULL */

  for (to = buf; *s; s++) {
    if (*s & TOKEN_BIT) {
      token = tokens[*s & TOKEN_MASK];
      *to++ = *token++;
      *to++ = *token;
    } else {
      *to++ = *s;
    }
  }

  *to++ = *s;

  return buf;
}

#endif				/* COMPRESS */