*.c: General spring-clean of the coding style.

[anag] / mono.c

/* -*-c-*-
 *
 * Monoalphabetic matcher
 *
 * (c) 2003 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of Anag: a simple wordgame helper.
 *
 * Anag is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Anag is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Anag; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "anag.h"

/*----- Data structures ---------------------------------------------------*/

typedef struct node_mono {
  node n;
  unsigned len;
  unsigned char *p;
} node_mono;

/*----- Main code ---------------------------------------------------------*/

/* --- Matching --- */

static int n_mono(node *nn, const char *p, size_t sz)
{
  node_mono *n = (node_mono *)nn;
  unsigned map[UCHAR_MAX];
  const unsigned char *q = n->p;
  unsigned max = 0;
  int ch;

  /* Monoalphabetic substitution preserves length. */
  if (sz != n->len) return (0);

  /* Canonicalize this string as we did the pattern.  Fail if we find a
   * mismatch.
   */
  memset(map, UCHAR_MAX, sizeof(map));
  while (*p) {
    ch = *p++;
    if (map[ch] >= max) map[ch] = max++;
    if (max >= UCHAR_MAX) return (0);
    if (*q++ != map[ch]) return (0);
  }
  return (1);
}

/* --- Node creation --- */

node *mono(const char *const *av)
{
  unsigned char map[UCHAR_MAX];
  const char *p = av[0];
  unsigned char *q;
  unsigned max = 0;
  int ch;

  node_mono *n = xmalloc(sizeof(*n));
  n->n.func = n_mono;
  n->p = q = xmalloc(n->len);
  n->len = strlen(p);

  /* Convert the string into the canonical representative of its equivalence
   * class, specifically the lexically first string which is equivalent under
   * monoalphabetic substitution.  That is: replace the first distinct
   * character with zero, the second with one, and so on.
   */
  memset(map, UCHAR_MAX, sizeof(map));
  while (*p) {
    ch = *p++;
    if (map[ch] >= max) map[ch] = max++;
    assert(max < UCHAR_MAX);
    *q++ = map[ch];
  }

  return (&n->n);
}

/*----- That's all, folks -------------------------------------------------*/