pcre.c, etc.: Support the PCRE2 library.

[anag] / trackword.c

/* -*-c-*-
 *
 * Matches trackwords
 *
 * (c) 2001 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 ---------------------------------------------------*/

#define NDIR 9

typedef struct tcell {
  struct tcell *hop[NDIR];
  char ch;
  unsigned char f;
} tcell;

typedef struct node_track {
  node n;
  unsigned x;
  unsigned y;
  tcell *c;
} node_track;

/*----- Utility functions -------------------------------------------------*/

/* --- @isqrt@ --- *
 *
 * Arguments:	@long a@ = the target value
 *
 * Returns:	%$\lfloor \sqrt{a} \rfloor$%
 *
 * Use:		Computes an integer square root.  This algorithm is
 *		Newton-Raphson with integers.  I've stolen this more-or-less
 *		wholesale fom the multiprecision integer square-root function
 *		in Catacomb.
 */

long isqrt(long a)
{
  long i, q;

  /* --- Initial guess is half the input length --- */

  for (i = q = a; q; q >>= 2)
    i >>= 1;

  /* --- Do the main series iteration --- */

  for (;;) {
    q = i * i - a;
    if (!q || (q < 0 && -q <= 2 * i))
      return (i);
    q /= 2 * i;
    if (!q)
      i--;
    else
      i -= q;
  }
}

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

/* --- @track@ --- *
 *
 * Arguments:	@tcell *c@ = pointer to start cell
 *		@const char *p@ = string to match
 *
 * Returns:	Nonzero for a match, zero if no match was found.
 *
 * Use:		Searches for a match in a trackword.
 */

static int track(tcell *c, const char *p)
{
  tcell **cc;

  if (*p++ != c->ch)
    return (0);
  if (!*p)
    return (1);
  c->f = 1;

  for (cc = c->hop; *cc; cc++) {
    if ((*cc)->f)
      continue;
    if (track(*cc, p)) {
      c->f = 0;
      return (1);
    }
  }
  c->f = 0;
  return (0);
}

/* --- Node matcher --- */

static int n_track(node *nn, const char *p, size_t sz)
{
  node_track *n = (node_track *)nn;
  tcell *c;

  if (!*p)
    return (1);
  for (c = n->c; c->ch; c++) {
    if (track(c, p))
      return (1);
  }
  return (0);
}

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

node *trackword(const char *const *av)
{
  node_track *n;
  unsigned x, y;
  unsigned i, j;
  const char *p = av[0], *q, *l;
  size_t sz = strlen(p);
  tcell *c, **cc, **ccc;

  /* --- Work out the dimensions --- */

  x = strcspn(p, "/");
  if (!p[x]) {
    x = isqrt(sz);
    if (x * x != sz)
      die("bad trackword `%s': not square, and no line markers", p);
    y = x;
  }

  if (!x)
    die("bad trackword `%s': no columns", p);

  y = 0;
  l = p + sz;
  q = p;
  for (;;) {
    if (*q == '/')
      q++;
    if (!*q)
      break;
    if (l - q < x)
      die("bad trackword `%s': inconsistent line lengths", p);
    q += x;
    y++;
  }

  if (!y)
    die("bad trackword `%s': no rows", p);

  /* --- Build the match node --- */

  n = xmalloc(sizeof(*n));
  n->n.func = n_track;
  n->x = x; n->y = y;
  n->c = xmalloc((x * y + 1) * sizeof(tcell));

  q = p;
  c = n->c;
  for (j = 0; j < y; j++) {
    if (*q == '/')
      q++;
    for (i = 0; i < x; i++) {
      c->ch = *q++;
      c->f = 0;
      cc = c->hop;

#define NOK (j > 0)
#define SOK (j < y - 1)
#define WOK (i > 0)
#define EOK (i < x - 1)

      if (NOK) *cc++ = c - x;
      if (SOK) *cc++ = c + x;
      if (WOK) *cc++ = c - 1;
      if (EOK) *cc++ = c + 1;

      if (NOK && WOK) *cc++ = c - x - 1;
      if (NOK && EOK) *cc++ = c - x + 1;
      if (SOK && WOK) *cc++ = c + x - 1;
      if (SOK && EOK) *cc++ = c + x + 1;

#undef NOK
#undef SOK
#undef WOK
#undef EOK

      *cc++ = 0;
      c++;
    }
  }
  c->ch = 0;

  /* --- Now prune out bogus links --- */

  for (c = n->c; c->ch; c++) {
    ccc = c->hop;
    for (cc = c->hop; *cc; cc++) {
      if (isalpha((unsigned char)(*cc)->ch)) {
	*ccc++ = *cc;
      }
    }
    *ccc++ = 0;
  }

  /* --- Done --- */

  return (&n->n);
}

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