server/common/utils.C

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT 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 3 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <crossfire@schmorp.de>
 */

/*
 * General convenience functions for crossfire.
 */

#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include <signal.h>

#include <global.h>
#include <funcpoint.h>
#include <material.h>

#include <glib.h>

refcnt_base::refcnt_t refcnt_dummy;

rand_gen rndm;

void
tausworthe_random_generator::seed (uint32_t seed)
{
  state [0] = seed      * 69069U; if (state [0] <  2U) state [0] +=   2U;
  state [1] = state [0] * 69069U; if (state [0] <  8U) state [0] +=   8U;
  state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] +=  16U;
  state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;

  for (int i = 11; --i; )
    operator ()();
}

uint32_t
tausworthe_random_generator::next ()
{
  state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] <<  6U) ^ state [0]) >> 13U);
  state [1] = ((state [1] & 0xFFFFFFF8U) <<  2U) ^ (((state [1] <<  2U) ^ state [1]) >> 27U);
  state [2] = ((state [2] & 0xFFFFFFF0U) <<  7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
  state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] <<  3U) ^ state [3]) >> 12U);

  return state [0] ^ state [1] ^ state [2] ^ state [3];
}

uint32_t
tausworthe_random_generator::get_range (uint32_t num)
{
  return (next () * (uint64_t)num) >> 32U;
}

// return a number within (min .. max)
int 
tausworthe_random_generator::get_range (int r_min, int r_max)
{
  return r_min + get_range (max (r_max - r_min + 1, 0));
}

/*
 * The random functions here take luck into account when rolling random
 * dice or numbers.  This function has less of an impact the larger the
 * difference becomes in the random numbers.  IE, the effect is lessened
 * on a 1-1000 roll, vs a 1-6 roll.  This can be used by crafty programmers,
 * to specifically disable luck in certain rolls, simply by making the
 * numbers larger (ie, 1d1000 > 500 vs 1d6 > 3)
 */

/*
 * Roll a random number between min and max.  Uses op to determine luck,
 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
 * Generally, op should be the player/caster/hitter requesting the roll,
 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
 */
int
random_roll (int r_min, int r_max, const object *op, int goodbad)
{
  int base = r_max - r_min > 1 ? 20 : 50;     /* d2 and d3 are corner cases */

  if (r_max < r_min)
    {
      LOG (llevError | logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
      return r_min;
    }

  if (op->type == PLAYER)
    {
      int luck = op->stats.luck;

      if (rndm (base) < min (10, abs (luck)))
        {
          //TODO: take luck into account
        }
    }

  return rndm (r_min, r_max);
}

/*
 * This is a 64 bit version of random_roll above.  This is needed
 * for exp loss calculations for players changing religions.
 */
sint64
random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
{
  sint64 omin = min;
  sint64 diff = max - min + 1;
  int base = diff > 2 ? 20 : 50;     /* d2 and d3 are corner cases */

  if (diff < 0)
    {
      LOG (llevError | logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
      return (min);             /* avoids a float exception */
    }

  /* 
   * Make a call to get two 32 bit unsigned random numbers, and just to
   * a little bitshifting.
   */
  sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);

  if (op->type != PLAYER)
    return ((ran % diff) + min);

  int luck = op->stats.luck;

  if (rndm (base) < MIN (10, abs (luck)))
    {
      /* we have a winner */
      ((luck > 0) ? (luck = 1) : (luck = -1));
      diff -= luck;
      if (diff < 1)
        return (omin);          /*check again */

      ((goodbad) ? (min += luck) : (diff));

      return (MAX (omin, MIN (max, (ran % diff) + min)));
    }

  return ran % diff + min;
}

/*
 * Roll a number of dice (2d3, 4d6).  Uses op to determine luck,
 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
 * Generally, op should be the player/caster/hitter requesting the roll,
 * not the recipient (ie, the poor slob getting hit).
 * The args are num D size (ie 4d6)  [garbled 20010916]
 */
int
die_roll (int num, int size, const object *op, int goodbad)
{
  int min, luck, total, i, gotlucky;

  int diff = size;
  min = 1;
  luck = total = gotlucky = 0;
  int base = diff > 2 ? 20 : 50;     /* d2 and d3 are corner cases */

  if (size < 2 || diff < 1)
    {
      LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
      return num;             /* avoids a float exception */
    }

  if (op->type == PLAYER)
    luck = op->stats.luck;

  for (i = 0; i < num; i++)
    {
      if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
        {
          /* we have a winner */
          gotlucky++;
          ((luck > 0) ? (luck = 1) : (luck = -1));
          diff -= luck;
          if (diff < 1)
            return (num);       /*check again */
          ((goodbad) ? (min += luck) : (diff));
          total += MAX (1, MIN (size, rndm (diff) + min));
        }
      else
        total += rndm (size) + 1;
    }

  return total;
}

/* convert materialname to materialtype_t */

materialtype_t *
name_to_material (const shstr &name)
{
  for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
    if (name == mt->name)
      return mt;

  return 0;
}

/* when doing transmutation of objects, we have to recheck the resistances,
 * as some that did not apply previously, may apply now.
 */

void
transmute_materialname (object *op, const object *change)
{
  materialtype_t *mt;
  int j;

  if (op->materialname == NULL)
    return;

  if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
    return;

  if (!op->is_armor ())
    return;

  mt = name_to_material (op->materialname);
  if (!mt)
    {
      LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
      return;
    }

  for (j = 0; j < NROFATTACKS; j++)
    if (op->resist[j] == 0 && change->resist[j] != 0)
      {
        op->resist[j] += mt->mod[j];
        if (op->resist[j] > 100)
          op->resist[j] = 100;
        if (op->resist[j] < -100)
          op->resist[j] = -100;
      }
}

/* set the materialname and type for an item */
void
set_materialname (object *op, int difficulty, materialtype_t *nmt)
{
  materialtype_t *mt, *lmt;

  if (op->materialname != NULL)
    return;

  if (nmt == NULL)
    {
      lmt = NULL;

      for (mt = materialt; mt && mt->next; mt = mt->next)
        if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
            difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
          {
            lmt = mt;
            if (!(op->is_weapon () || op->is_armor ()))
              break;
          }
    }
  else
    lmt = nmt;

  if (lmt != NULL)
    {
      if (op->stats.dam && op->is_weapon ())
        {
          op->stats.dam += lmt->damage;
          if (op->stats.dam < 1)
            op->stats.dam = 1;
        }

      if (op->stats.sp && op->type == BOW)
        op->stats.sp += lmt->sp;
      if (op->stats.wc && op->is_weapon ())
        op->stats.wc += lmt->wc;
      if (op->is_armor ())
        {
          if (op->stats.ac)
            op->stats.ac += lmt->ac;

          for (int j = 0; j < NROFATTACKS; j++)
            if (op->resist[j] != 0)
              {
                op->resist[j] += lmt->mod[j];
                if (op->resist[j] > 100)
                  op->resist[j] = 100;
                if (op->resist[j] < -100)
                  op->resist[j] = -100;
              }
        }

      op->materialname = lmt->name;
      /* dont make it unstackable if it doesn't need to be */
      if (op->is_weapon () || op->is_armor ())
        {
          op->weight = (op->weight * lmt->weight) / 100;
          op->value = (op->value * lmt->value) / 100;
        }
    }
}

/*
 * Strip out the media tags from a String.
 * Warning the input string will contain the result string
 */
void
strip_media_tag (char *message)
{
  int in_tag = 0;
  char *dest;
  char *src;

  src = dest = message;
  while (*src != '\0')
    {
      if (*src == '[')
        {
          in_tag = 1;
        }
      else if (in_tag && (*src == ']'))
        in_tag = 0;
      else if (!in_tag)
        {
          *dest = *src;
          dest++;
        }
      src++;
    }
  *dest = '\0';
}

const char *
strrstr (const char *haystack, const char *needle)
{
  const char *lastneedle;

  lastneedle = NULL;
  while ((haystack = strstr (haystack, needle)) != NULL)
    {
      lastneedle = haystack;
      haystack++;
    }
  return lastneedle;

}

#define EOL_SIZE (sizeof("\n")-1)
void
strip_endline (char *buf)
{
  if (strlen (buf) < sizeof ("\n"))
    {
      return;
    }
  if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
    buf[strlen (buf) - EOL_SIZE] = '\0';
}

/**
 * Replace in string src all occurrences of key by replacement. The resulting
 * string is put into result; at most resultsize characters (including the
 * terminating null character) will be written to result.
 */
void
replace (const char *src, const char *key, const char *replacement, char *result, size_t resultsize)
{
  size_t resultlen;
  size_t keylen;

  /* special case to prevent infinite loop if key==replacement=="" */
  if (strcmp (key, replacement) == 0)
    {
      snprintf (result, resultsize, "%s", src);
      return;
    }

  keylen = strlen (key);

  resultlen = 0;
  while (*src != '\0' && resultlen + 1 < resultsize)
    {
      if (strncmp (src, key, keylen) == 0)
        {
          snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
          resultlen += strlen (result + resultlen);
          src += keylen;
        }
      else
        {
          result[resultlen++] = *src++;
        }
    }
  result[resultlen] = '\0';
}

/**
 * Taking a string as an argument, mutate it into a string that looks like a list.
 * a 'list' for the purposes here, is a string of items, seperated by commas, except
 * for the last entry, which has an 'and' before it, and a full stop (period) after it.
 * This function will also strip all trailing non alphanumeric characters.
 * It does not insert an oxford comma.
 */

void
make_list_like (char *input)
{
  char *p, tmp[MAX_BUF];
  int i;

  if (!input || strlen (input) > MAX_BUF - 5)
    return;
  /* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */

  strncpy (tmp, input, MAX_BUF - 5);
  /*trim all trailing commas, spaces etc. */
  for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
    tmp[i] = '\0';

  strcat (tmp, ".");

  p = strrchr (tmp, ',');
  if (p)
    {
      *p = '\0';
      strcpy (input, tmp);
      p++;
      strcat (input, " and");
      strcat (input, p);
    }
  else
    strcpy (input, tmp);

  return;
}

/////////////////////////////////////////////////////////////////////////////

void
fork_abort (const char *msg)
{
  if (!fork ())
    {
      signal (SIGABRT, SIG_DFL);
      // try to put corefiles into a subdirectory, if existing, to allow
      // an administrator to reduce the I/O load.
      chdir ("cores");
      abort ();
    }

  LOG (llevError, "fork abort: %s\n", msg);
}

void *salloc_ (int n) throw (std::bad_alloc)
{
#ifdef PREFER_MALLOC
  void *ptr = malloc (n);
#else
  void *ptr = g_slice_alloc (n);
#endif

  if (!ptr)
    throw std::bad_alloc ();

  return ptr;
}

void *salloc_ (int n, void *src) throw (std::bad_alloc)
{
  void *ptr = salloc_ (n);

  if (src)
    memcpy (ptr, src, n);
  else
    memset (ptr, 0, n);

  return ptr;
}

void assign (char *dst, const char *src, int maxlen)
{
  if (!src)
    src = "";

  int len = strlen (src);

  if (len >= maxlen - 1)
    {
      if (maxlen <= 4)
        {
          memset (dst, '.', maxlen - 1);
          dst [maxlen - 1] = 0;
        }
      else
        {
          memcpy (dst, src, maxlen - 4);
          memcpy (dst + maxlen - 4, "...", 4);
        }
    }
  else
    memcpy (dst, src, len + 1);
}

const std::string
format (const char *format, ...)
{
  int len;

  {
    char buf[128];

    va_list ap;
    va_start (ap, format);
    len = vsnprintf (buf, sizeof (buf), format, ap);
    va_end (ap);

    assert (len >= 0); // shield againstz broken vsnprintf's

    // was our static buffer short enough?
    if (len < sizeof (buf))
      return std::string (buf, len);
  }

  {
    // longer, try harder
    char *buf = salloc<char> (len + 1);

    va_list ap;
    va_start (ap, format);
    vsnprintf (buf, len + 1, format, ap);
    va_end (ap);

    const std::string s (buf, len);
    sfree<char> (buf, len + 1);
      
    return buf;
  }
}

tstamp now ()
{
  struct timeval tv;

  gettimeofday (&tv, 0);
  return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
}

int
similar_direction (int a, int b)
{
  if (!a || !b)
    return 0;

  int diff = (b - a) & 7;
  return diff <= 1 || diff >= 7;
}

/* crc32 0xdebb20e3 table and supplementary functions.  */
extern const uint32_t crc_32_tab[256] =
{
    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
    0x2d02ef8dL
};

#if 0
void xyzzy (object_ptr &a, object_ptr &o)
{
  asm volatile ("int3");
  a = o;
  asm volatile ("int3");
}
#endif

Revision:	1.63
Committed:	Mon Aug 6 10:54:11 2007 UTC (16 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.62:	+10 -0 lines
Log Message:	rather uncertain optimisation.. trying to take advantage of cmov instructions if refptr. a = b before: 510: 48 8b 16 mov (%rsi),%rdx 513: 48 85 d2 test %rdx,%rdx 516: 75 0c jne 524 <xyzzy(refptr<object>, refptr<object>)+0x14> 518: 48 8b 07 mov (%rdi),%rax 51b: 48 85 c0 test %rax,%rax 51e: 75 09 jne 529 <xyzzy(refptr<object>, refptr<object>)+0x19> 520: 48 89 17 mov %rdx,(%rdi) 523: c3 retq 524: ff 42 08 incl 0x8(%rdx) 527: eb ef jmp 518 <xyzzy(refptr<object>, refptr<object>)+0x8> 529: ff 48 08 decl 0x8(%rax) 52c: 0f 1f 40 00 nopl 0x0(%rax) 530: eb ee jmp 520 <xyzzy(refptr<object>, refptr<object>)+0x10> a = b after: 141: 4c 8b 0f mov (%rdi),%r9 144: ba 00 00 00 00 mov $0x0,%edx 149: 4d 8d 41 08 lea 0x8(%r9),%r8 14d: 4d 85 c9 test %r9,%r9 150: 4c 0f 44 c2 cmove %rdx,%r8 154: 41 ff 08 decl (%r8) 157: 48 8b 06 mov (%rsi),%rax 15a: 48 8d 48 08 lea 0x8(%rax),%rcx 15e: 48 85 c0 test %rax,%rax 161: 48 89 07 mov %rax,(%rdi) 164: 48 0f 45 d1 cmovne %rcx,%rdx 168: ff 02 incl (%rdx) 16a: c3 retq note no jumps but larger codeside (1.7kb net increase).
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.60	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	pippijn	1.39	*
4	root	1.57	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5			* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6			* Copyright (©) 1992,2007 Frank Tore Johansen
7	pippijn	1.39	*
8	root	1.60	* Crossfire TRT is free software: you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation, either version 3 of the License, or
11			* (at your option) any later version.
12	pippijn	1.39	*
13	root	1.60	* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17	pippijn	1.39	*
18	root	1.60	* You should have received a copy of the GNU General Public License
19			* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	root	1.57	*
21			* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	pippijn	1.39	*/
23	elmex	1.1
24			/*
25			* General convenience functions for crossfire.
26			*/
27
28	root	1.37	#include <cstdlib>
29			#include <sys/types.h>
30			#include <unistd.h>
31			#include <sys/time.h>
32			#include <time.h>
33			#include <signal.h>
34
35	elmex	1.1	#include <global.h>
36			#include <funcpoint.h>
37			#include <material.h>
38
39	root	1.4	#include <glib.h>
40
41	root	1.63	refcnt_base::refcnt_t refcnt_dummy;
42
43	root	1.42	rand_gen rndm;
44	root	1.40
45	root	1.42	void
46			tausworthe_random_generator::seed (uint32_t seed)
47	root	1.40	{
48	root	1.49	state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
49			state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
50			state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
51			state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;
52	root	1.40
53			for (int i = 11; --i; )
54			operator ()();
55			}
56
57			uint32_t
58			tausworthe_random_generator::next ()
59			{
60			state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] << 6U) ^ state [0]) >> 13U);
61			state [1] = ((state [1] & 0xFFFFFFF8U) << 2U) ^ (((state [1] << 2U) ^ state [1]) >> 27U);
62			state [2] = ((state [2] & 0xFFFFFFF0U) << 7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
63			state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
64
65			return state [0] ^ state [1] ^ state [2] ^ state [3];
66			}
67
68	root	1.42	uint32_t
69	root	1.50	tausworthe_random_generator::get_range (uint32_t num)
70	root	1.42	{
71	root	1.50	return (next () * (uint64_t)num) >> 32U;
72	root	1.42	}
73
74			// return a number within (min .. max)
75			int
76			tausworthe_random_generator::get_range (int r_min, int r_max)
77			{
78	root	1.50	return r_min + get_range (max (r_max - r_min + 1, 0));
79	root	1.42	}
80
81	elmex	1.1	/*
82			* The random functions here take luck into account when rolling random
83			* dice or numbers. This function has less of an impact the larger the
84			* difference becomes in the random numbers. IE, the effect is lessened
85			* on a 1-1000 roll, vs a 1-6 roll. This can be used by crafty programmers,
86			* to specifically disable luck in certain rolls, simply by making the
87			* numbers larger (ie, 1d1000 > 500 vs 1d6 > 3)
88			*/
89
90			/*
91			* Roll a random number between min and max. Uses op to determine luck,
92			* and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
93			* Generally, op should be the player/caster/hitter requesting the roll,
94			* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
95			*/
96	root	1.9	int
97	root	1.41	random_roll (int r_min, int r_max, const object *op, int goodbad)
98	root	1.9	{
99	root	1.41	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
100	elmex	1.1
101	root	1.55	if (r_max < r_min)
102	root	1.9	{
103	root	1.54	LOG (llevError \| logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
104	root	1.41	return r_min;
105	elmex	1.1	}
106
107	root	1.41	if (op->type == PLAYER)
108	root	1.9	{
109	root	1.41	int luck = op->stats.luck;
110	elmex	1.1
111	root	1.41	if (rndm (base) < min (10, abs (luck)))
112			{
113			//TODO: take luck into account
114			}
115	elmex	1.1	}
116	root	1.41
117			return rndm (r_min, r_max);
118	elmex	1.1	}
119
120			/*
121			* This is a 64 bit version of random_roll above. This is needed
122			* for exp loss calculations for players changing religions.
123			*/
124	root	1.9	sint64
125			random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
126			{
127	root	1.55	sint64 omin = min;
128			sint64 diff = max - min + 1;
129			int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
130	root	1.9
131	root	1.55	if (diff < 0)
132	root	1.9	{
133	root	1.54	LOG (llevError \| logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
134	root	1.9	return (min); /* avoids a float exception */
135	elmex	1.1	}
136
137	root	1.45	/*
138			* Make a call to get two 32 bit unsigned random numbers, and just to
139			* a little bitshifting.
140	root	1.9	*/
141	root	1.55	sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
142	root	1.9
143			if (op->type != PLAYER)
144			return ((ran % diff) + min);
145
146	root	1.55	int luck = op->stats.luck;
147
148	root	1.45	if (rndm (base) < MIN (10, abs (luck)))
149	root	1.9	{
150			/* we have a winner */
151			((luck > 0) ? (luck = 1) : (luck = -1));
152			diff -= luck;
153			if (diff < 1)
154			return (omin); /check again /
155	root	1.55
156	root	1.9	((goodbad) ? (min += luck) : (diff));
157	elmex	1.1
158	root	1.9	return (MAX (omin, MIN (max, (ran % diff) + min)));
159	elmex	1.1	}
160	root	1.45
161	root	1.55	return ran % diff + min;
162	elmex	1.1	}
163
164			/*
165			* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
166			* If goodbad is non-zero, luck increases the roll, if zero, it decreases.
167			* Generally, op should be the player/caster/hitter requesting the roll,
168			* not the recipient (ie, the poor slob getting hit).
169			* The args are num D size (ie 4d6) [garbled 20010916]
170			*/
171	root	1.9	int
172			die_roll (int num, int size, const object *op, int goodbad)
173			{
174	root	1.55	int min, luck, total, i, gotlucky;
175	root	1.9
176	root	1.55	int diff = size;
177	root	1.9	min = 1;
178			luck = total = gotlucky = 0;
179	root	1.55	int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
180
181	root	1.9	if (size < 2 \|\| diff < 1)
182			{
183			LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
184	root	1.55	return num; /* avoids a float exception */
185	root	1.9	}
186	elmex	1.1
187	root	1.9	if (op->type == PLAYER)
188			luck = op->stats.luck;
189
190			for (i = 0; i < num; i++)
191			{
192	root	1.45	if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
193	root	1.9	{
194			/* we have a winner */
195			gotlucky++;
196			((luck > 0) ? (luck = 1) : (luck = -1));
197			diff -= luck;
198			if (diff < 1)
199			return (num); /check again /
200			((goodbad) ? (min += luck) : (diff));
201	root	1.45	total += MAX (1, MIN (size, rndm (diff) + min));
202	root	1.9	}
203			else
204	root	1.45	total += rndm (size) + 1;
205	elmex	1.1	}
206	root	1.45
207			return total;
208	elmex	1.1	}
209
210			/* convert materialname to materialtype_t */
211
212	root	1.9	materialtype_t *
213	root	1.47	name_to_material (const shstr &name)
214	elmex	1.1	{
215	root	1.47	for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
216			if (name == mt->name)
217			return mt;
218	elmex	1.1
219	root	1.62	return 0;
220	elmex	1.1	}
221
222			/* when doing transmutation of objects, we have to recheck the resistances,
223			* as some that did not apply previously, may apply now.
224			*/
225
226	root	1.9	void
227			transmute_materialname (object op, const object change)
228	elmex	1.1	{
229	root	1.9	materialtype_t *mt;
230			int j;
231	elmex	1.1
232	root	1.9	if (op->materialname == NULL)
233			return;
234	elmex	1.1
235	root	1.9	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
236			return;
237
238	root	1.26	if (!op->is_armor ())
239	root	1.9	return;
240
241			mt = name_to_material (op->materialname);
242			if (!mt)
243			{
244	root	1.58	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
245	root	1.9	return;
246			}
247
248			for (j = 0; j < NROFATTACKS; j++)
249			if (op->resist[j] == 0 && change->resist[j] != 0)
250			{
251			op->resist[j] += mt->mod[j];
252			if (op->resist[j] > 100)
253			op->resist[j] = 100;
254			if (op->resist[j] < -100)
255			op->resist[j] = -100;
256			}
257	elmex	1.1	}
258
259			/* set the materialname and type for an item */
260	root	1.9	void
261			set_materialname (object op, int difficulty, materialtype_t nmt)
262	elmex	1.1	{
263	root	1.9	materialtype_t mt, lmt;
264
265			if (op->materialname != NULL)
266			return;
267	elmex	1.1
268	root	1.9	if (nmt == NULL)
269			{
270			lmt = NULL;
271	root	1.61
272	root	1.47	for (mt = materialt; mt && mt->next; mt = mt->next)
273	root	1.61	if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
274			difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
275			{
276			lmt = mt;
277			if (!(op->is_weapon () \|\| op->is_armor ()))
278	root	1.9	break;
279	root	1.61	}
280	root	1.9	}
281			else
282	root	1.61	lmt = nmt;
283	elmex	1.1
284	root	1.9	if (lmt != NULL)
285			{
286	root	1.26	if (op->stats.dam && op->is_weapon ())
287	root	1.9	{
288			op->stats.dam += lmt->damage;
289			if (op->stats.dam < 1)
290			op->stats.dam = 1;
291			}
292	root	1.46
293	root	1.9	if (op->stats.sp && op->type == BOW)
294			op->stats.sp += lmt->sp;
295	root	1.26	if (op->stats.wc && op->is_weapon ())
296	root	1.9	op->stats.wc += lmt->wc;
297	root	1.26	if (op->is_armor ())
298	root	1.9	{
299			if (op->stats.ac)
300			op->stats.ac += lmt->ac;
301	root	1.61
302			for (int j = 0; j < NROFATTACKS; j++)
303	root	1.9	if (op->resist[j] != 0)
304			{
305			op->resist[j] += lmt->mod[j];
306			if (op->resist[j] > 100)
307			op->resist[j] = 100;
308			if (op->resist[j] < -100)
309			op->resist[j] = -100;
310			}
311			}
312	root	1.61
313	root	1.46	op->materialname = lmt->name;
314	root	1.9	/* dont make it unstackable if it doesn't need to be */
315	root	1.26	if (op->is_weapon () \|\| op->is_armor ())
316	root	1.9	{
317			op->weight = (op->weight * lmt->weight) / 100;
318			op->value = (op->value * lmt->value) / 100;
319	root	1.2	}
320	elmex	1.1	}
321			}
322
323			/*
324			* Strip out the media tags from a String.
325			* Warning the input string will contain the result string
326			*/
327	root	1.9	void
328			strip_media_tag (char *message)
329			{
330			int in_tag = 0;
331			char *dest;
332			char *src;
333
334			src = dest = message;
335			while (*src != '\0')
336			{
337			if (*src == '[')
338			{
339			in_tag = 1;
340			}
341			else if (in_tag && (*src == ']'))
342			in_tag = 0;
343			else if (!in_tag)
344			{
345			dest = src;
346			dest++;
347			}
348			src++;
349			}
350			*dest = '\0';
351			}
352
353			const char *
354			strrstr (const char haystack, const char needle)
355			{
356			const char *lastneedle;
357
358			lastneedle = NULL;
359			while ((haystack = strstr (haystack, needle)) != NULL)
360			{
361			lastneedle = haystack;
362			haystack++;
363	elmex	1.1	}
364	root	1.9	return lastneedle;
365
366	elmex	1.1	}
367	root	1.9
368	elmex	1.1	#define EOL_SIZE (sizeof("\n")-1)
369	root	1.9	void
370			strip_endline (char *buf)
371			{
372			if (strlen (buf) < sizeof ("\n"))
373			{
374			return;
375	elmex	1.1	}
376	root	1.9	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
377			buf[strlen (buf) - EOL_SIZE] = '\0';
378	elmex	1.1	}
379
380			/**
381			* Replace in string src all occurrences of key by replacement. The resulting
382			* string is put into result; at most resultsize characters (including the
383			* terminating null character) will be written to result.
384			*/
385	root	1.9	void
386			replace (const char src, const char key, const char replacement, char result, size_t resultsize)
387	elmex	1.1	{
388	root	1.9	size_t resultlen;
389			size_t keylen;
390	elmex	1.1
391	root	1.9	/* special case to prevent infinite loop if key==replacement=="" */
392			if (strcmp (key, replacement) == 0)
393			{
394			snprintf (result, resultsize, "%s", src);
395			return;
396			}
397
398			keylen = strlen (key);
399
400			resultlen = 0;
401			while (*src != '\0' && resultlen + 1 < resultsize)
402			{
403			if (strncmp (src, key, keylen) == 0)
404	root	1.2	{
405	root	1.9	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
406			resultlen += strlen (result + resultlen);
407			src += keylen;
408	root	1.2	}
409	root	1.9	else
410	root	1.2	{
411	root	1.9	result[resultlen++] = *src++;
412	root	1.2	}
413	root	1.9	}
414			result[resultlen] = '\0';
415	elmex	1.1	}
416
417			/**
418			* Taking a string as an argument, mutate it into a string that looks like a list.
419			* a 'list' for the purposes here, is a string of items, seperated by commas, except
420			* for the last entry, which has an 'and' before it, and a full stop (period) after it.
421			* This function will also strip all trailing non alphanumeric characters.
422			* It does not insert an oxford comma.
423			*/
424
425	root	1.9	void
426			make_list_like (char *input)
427			{
428			char *p, tmp[MAX_BUF];
429			int i;
430
431			if (!input \|\| strlen (input) > MAX_BUF - 5)
432	elmex	1.1	return;
433	root	1.9	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
434
435			strncpy (tmp, input, MAX_BUF - 5);
436			/trim all trailing commas, spaces etc. /
437			for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
438			tmp[i] = '\0';
439	root	1.11
440	root	1.9	strcat (tmp, ".");
441
442			p = strrchr (tmp, ',');
443			if (p)
444			{
445			*p = '\0';
446			strcpy (input, tmp);
447			p++;
448			strcat (input, " and");
449			strcat (input, p);
450			}
451			else
452			strcpy (input, tmp);
453	root	1.11
454	root	1.9	return;
455	elmex	1.1	}
456	root	1.3
457	root	1.14	/////////////////////////////////////////////////////////////////////////////
458
459	root	1.37	void
460			fork_abort (const char *msg)
461			{
462			if (!fork ())
463			{
464			signal (SIGABRT, SIG_DFL);
465	root	1.52	// try to put corefiles into a subdirectory, if existing, to allow
466			// an administrator to reduce the I/O load.
467			chdir ("cores");
468	root	1.37	abort ();
469			}
470
471	root	1.38	LOG (llevError, "fork abort: %s\n", msg);
472	root	1.37	}
473	root	1.38
474	root	1.25	void *salloc_ (int n) throw (std::bad_alloc)
475	root	1.10	{
476	root	1.44	#ifdef PREFER_MALLOC
477			void *ptr = malloc (n);
478			#else
479	root	1.25	void *ptr = g_slice_alloc (n);
480	root	1.44	#endif
481	root	1.13
482	root	1.23	if (!ptr)
483	root	1.13	throw std::bad_alloc ();
484	root	1.4
485	root	1.23	return ptr;
486			}
487
488	root	1.25	void salloc_ (int n, void src) throw (std::bad_alloc)
489	root	1.23	{
490	root	1.25	void *ptr = salloc_ (n);
491	root	1.23
492	root	1.24	if (src)
493	root	1.25	memcpy (ptr, src, n);
494	root	1.24	else
495	root	1.25	memset (ptr, 0, n);
496	root	1.23
497			return ptr;
498	root	1.3	}
499	root	1.11
500			void assign (char dst, const char src, int maxlen)
501			{
502			if (!src)
503			src = "";
504
505			int len = strlen (src);
506
507			if (len >= maxlen - 1)
508			{
509			if (maxlen <= 4)
510			{
511			memset (dst, '.', maxlen - 1);
512			dst [maxlen - 1] = 0;
513			}
514			else
515			{
516			memcpy (dst, src, maxlen - 4);
517			memcpy (dst + maxlen - 4, "...", 4);
518			}
519			}
520			else
521			memcpy (dst, src, len + 1);
522			}
523
524	root	1.51	const std::string
525			format (const char *format, ...)
526			{
527			int len;
528
529			{
530			char buf[128];
531
532			va_list ap;
533			va_start (ap, format);
534			len = vsnprintf (buf, sizeof (buf), format, ap);
535			va_end (ap);
536
537			assert (len >= 0); // shield againstz broken vsnprintf's
538
539			// was our static buffer short enough?
540			if (len < sizeof (buf))
541			return std::string (buf, len);
542			}
543
544			{
545			// longer, try harder
546			char *buf = salloc<char> (len + 1);
547
548			va_list ap;
549			va_start (ap, format);
550			vsnprintf (buf, len + 1, format, ap);
551			va_end (ap);
552
553			const std::string s (buf, len);
554			sfree<char> (buf, len + 1);
555
556			return buf;
557			}
558			}
559
560	root	1.23	tstamp now ()
561			{
562			struct timeval tv;
563
564			gettimeofday (&tv, 0);
565			return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
566			}
567	root	1.17
568	root	1.32	int
569			similar_direction (int a, int b)
570			{
571			if (!a \|\| !b)
572			return 0;
573
574			int diff = (b - a) & 7;
575			return diff <= 1 \|\| diff >= 7;
576			}
577
578	root	1.48	/* crc32 0xdebb20e3 table and supplementary functions. */
579			extern const uint32_t crc_32_tab[256] =
580			{
581			0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
582			0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
583			0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
584			0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
585			0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
586			0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
587			0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
588			0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
589			0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
590			0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
591			0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
592			0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
593			0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
594			0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
595			0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
596			0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
597			0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
598			0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
599			0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
600			0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
601			0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
602			0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
603			0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
604			0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
605			0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
606			0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
607			0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
608			0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
609			0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
610			0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
611			0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
612			0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
613			0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
614			0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
615			0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
616			0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
617			0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
618			0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
619			0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
620			0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
621			0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
622			0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
623			0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
624			0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
625			0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
626			0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
627			0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
628			0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
629			0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
630			0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
631			0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
632			0x2d02ef8dL
633			};
634
635	root	1.63	#if 0
636			void xyzzy (object_ptr &a, object_ptr &o)
637			{
638			asm volatile ("int3");
639			a = o;
640			asm volatile ("int3");
641			}
642			#endif
643	root	1.48