server/common/utils.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Deliantra 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 <support@deliantra.net>
 */

/*
 * 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;
size_t slice_alloc;
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
  slice_alloc += n;
  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;
}

/******************************************************************************/

#ifdef DEBUG_SALLOC

#define MAGIC 0xa1b2c35543deadLL

void *g_slice_alloc (unsigned long size)
{
  unsigned long *p = (unsigned long *) (g_slice_alloc)(size + sizeof (unsigned long));
  *p++ = size ^ MAGIC;
  //fprintf (stderr, "g_slice_alloc %ld %p\n", size, p);//D
  return (void *)p;
}

void *g_slice_alloc0 (unsigned long size)
{
  return memset (g_slice_alloc (size), 0, size);
}

void g_slice_free1 (unsigned long size, void *ptr)
{
  if (expect_true (ptr))
    {
      //fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D
      unsigned long *p = (unsigned long *)ptr;
      unsigned long s = *--p ^ MAGIC;

      if ((*p ^ MAGIC) != size)
        LOG (logBacktrace | llevError, "slice free size (%lx) doesn't match alloc size (%lx)\n", size, s);

      *p = MAGIC;

      (g_slice_free1)(s + sizeof (unsigned long), p);
    }
}

#endif

/******************************************************************************/

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 char *
format (const char *format, ...)
{
  static dynbuf_text buf;

  buf.clear ();

  va_list ap;
  va_start (ap, format);
  buf.vprintf (format, ap);
  va_end (ap);

  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
};

Revision:	1.70
Committed:	Fri Jan 25 18:09:23 2008 UTC (16 years, 4 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_41
Changes since 1.69:	+1 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.68	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	pippijn	1.39	*
4	root	1.68	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	root	1.57	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6			* Copyright (©) 1992,2007 Frank Tore Johansen
7	pippijn	1.39	*
8	root	1.68	* Deliantra is free software: you can redistribute it and/or modify
9	root	1.60	* 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	root	1.68	* The authors can be reached via e-mail to <support@deliantra.net>
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	root	1.67	size_t slice_alloc;
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	root	1.9	void
226			transmute_materialname (object op, const object change)
227	elmex	1.1	{
228	root	1.9	materialtype_t *mt;
229			int j;
230	elmex	1.1
231	root	1.9	if (op->materialname == NULL)
232			return;
233	elmex	1.1
234	root	1.9	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
235			return;
236
237	root	1.26	if (!op->is_armor ())
238	root	1.9	return;
239
240			mt = name_to_material (op->materialname);
241			if (!mt)
242			{
243	root	1.58	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
244	root	1.9	return;
245			}
246
247			for (j = 0; j < NROFATTACKS; j++)
248			if (op->resist[j] == 0 && change->resist[j] != 0)
249			{
250			op->resist[j] += mt->mod[j];
251			if (op->resist[j] > 100)
252			op->resist[j] = 100;
253			if (op->resist[j] < -100)
254			op->resist[j] = -100;
255			}
256	elmex	1.1	}
257
258			/* set the materialname and type for an item */
259	root	1.9	void
260			set_materialname (object op, int difficulty, materialtype_t nmt)
261	elmex	1.1	{
262	root	1.9	materialtype_t mt, lmt;
263
264			if (op->materialname != NULL)
265			return;
266	elmex	1.1
267	root	1.9	if (nmt == NULL)
268			{
269			lmt = NULL;
270	root	1.61
271	root	1.47	for (mt = materialt; mt && mt->next; mt = mt->next)
272	root	1.61	if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
273			difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
274			{
275			lmt = mt;
276			if (!(op->is_weapon () \|\| op->is_armor ()))
277	root	1.9	break;
278	root	1.61	}
279	root	1.9	}
280			else
281	root	1.61	lmt = nmt;
282	elmex	1.1
283	root	1.9	if (lmt != NULL)
284			{
285	root	1.26	if (op->stats.dam && op->is_weapon ())
286	root	1.9	{
287			op->stats.dam += lmt->damage;
288			if (op->stats.dam < 1)
289			op->stats.dam = 1;
290			}
291	root	1.46
292	root	1.9	if (op->stats.sp && op->type == BOW)
293			op->stats.sp += lmt->sp;
294	root	1.26	if (op->stats.wc && op->is_weapon ())
295	root	1.9	op->stats.wc += lmt->wc;
296	root	1.26	if (op->is_armor ())
297	root	1.9	{
298			if (op->stats.ac)
299			op->stats.ac += lmt->ac;
300	root	1.61
301			for (int j = 0; j < NROFATTACKS; j++)
302	root	1.9	if (op->resist[j] != 0)
303			{
304			op->resist[j] += lmt->mod[j];
305			if (op->resist[j] > 100)
306			op->resist[j] = 100;
307			if (op->resist[j] < -100)
308			op->resist[j] = -100;
309			}
310			}
311	root	1.61
312	root	1.46	op->materialname = lmt->name;
313	root	1.9	/* dont make it unstackable if it doesn't need to be */
314	root	1.26	if (op->is_weapon () \|\| op->is_armor ())
315	root	1.9	{
316			op->weight = (op->weight * lmt->weight) / 100;
317			op->value = (op->value * lmt->value) / 100;
318	root	1.2	}
319	elmex	1.1	}
320			}
321
322			/*
323			* Strip out the media tags from a String.
324			* Warning the input string will contain the result string
325			*/
326	root	1.9	void
327			strip_media_tag (char *message)
328			{
329			int in_tag = 0;
330			char *dest;
331			char *src;
332
333			src = dest = message;
334			while (*src != '\0')
335			{
336			if (*src == '[')
337			{
338			in_tag = 1;
339			}
340			else if (in_tag && (*src == ']'))
341			in_tag = 0;
342			else if (!in_tag)
343			{
344			dest = src;
345			dest++;
346			}
347			src++;
348			}
349			*dest = '\0';
350			}
351
352			const char *
353			strrstr (const char haystack, const char needle)
354			{
355			const char *lastneedle;
356
357			lastneedle = NULL;
358			while ((haystack = strstr (haystack, needle)) != NULL)
359			{
360			lastneedle = haystack;
361			haystack++;
362	elmex	1.1	}
363	root	1.9	return lastneedle;
364
365	elmex	1.1	}
366	root	1.9
367	elmex	1.1	#define EOL_SIZE (sizeof("\n")-1)
368	root	1.9	void
369			strip_endline (char *buf)
370			{
371			if (strlen (buf) < sizeof ("\n"))
372			{
373			return;
374	elmex	1.1	}
375	root	1.9	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
376			buf[strlen (buf) - EOL_SIZE] = '\0';
377	elmex	1.1	}
378
379			/**
380			* Replace in string src all occurrences of key by replacement. The resulting
381			* string is put into result; at most resultsize characters (including the
382			* terminating null character) will be written to result.
383			*/
384	root	1.9	void
385			replace (const char src, const char key, const char replacement, char result, size_t resultsize)
386	elmex	1.1	{
387	root	1.9	size_t resultlen;
388			size_t keylen;
389	elmex	1.1
390	root	1.9	/* special case to prevent infinite loop if key==replacement=="" */
391			if (strcmp (key, replacement) == 0)
392			{
393			snprintf (result, resultsize, "%s", src);
394			return;
395			}
396
397			keylen = strlen (key);
398
399			resultlen = 0;
400			while (*src != '\0' && resultlen + 1 < resultsize)
401			{
402			if (strncmp (src, key, keylen) == 0)
403	root	1.2	{
404	root	1.9	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
405			resultlen += strlen (result + resultlen);
406			src += keylen;
407	root	1.2	}
408	root	1.9	else
409	root	1.2	{
410	root	1.9	result[resultlen++] = *src++;
411	root	1.2	}
412	root	1.9	}
413			result[resultlen] = '\0';
414	elmex	1.1	}
415
416			/**
417			* Taking a string as an argument, mutate it into a string that looks like a list.
418			* a 'list' for the purposes here, is a string of items, seperated by commas, except
419			* for the last entry, which has an 'and' before it, and a full stop (period) after it.
420			* This function will also strip all trailing non alphanumeric characters.
421			* It does not insert an oxford comma.
422			*/
423	root	1.9	void
424			make_list_like (char *input)
425			{
426			char *p, tmp[MAX_BUF];
427			int i;
428
429			if (!input \|\| strlen (input) > MAX_BUF - 5)
430	elmex	1.1	return;
431	root	1.9	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
432
433			strncpy (tmp, input, MAX_BUF - 5);
434			/trim all trailing commas, spaces etc. /
435			for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
436			tmp[i] = '\0';
437	root	1.11
438	root	1.9	strcat (tmp, ".");
439
440			p = strrchr (tmp, ',');
441			if (p)
442			{
443			*p = '\0';
444			strcpy (input, tmp);
445			p++;
446			strcat (input, " and");
447			strcat (input, p);
448			}
449			else
450			strcpy (input, tmp);
451	root	1.11
452	root	1.9	return;
453	elmex	1.1	}
454	root	1.3
455	root	1.14	/////////////////////////////////////////////////////////////////////////////
456
457	root	1.37	void
458			fork_abort (const char *msg)
459			{
460			if (!fork ())
461			{
462			signal (SIGABRT, SIG_DFL);
463	root	1.52	// try to put corefiles into a subdirectory, if existing, to allow
464			// an administrator to reduce the I/O load.
465			chdir ("cores");
466	root	1.37	abort ();
467			}
468
469	root	1.38	LOG (llevError, "fork abort: %s\n", msg);
470	root	1.37	}
471	root	1.38
472	root	1.25	void *salloc_ (int n) throw (std::bad_alloc)
473	root	1.10	{
474	root	1.44	#ifdef PREFER_MALLOC
475			void *ptr = malloc (n);
476			#else
477	root	1.67	slice_alloc += n;
478	root	1.25	void *ptr = g_slice_alloc (n);
479	root	1.44	#endif
480	root	1.13
481	root	1.23	if (!ptr)
482	root	1.13	throw std::bad_alloc ();
483	root	1.4
484	root	1.23	return ptr;
485			}
486
487	root	1.25	void salloc_ (int n, void src) throw (std::bad_alloc)
488	root	1.23	{
489	root	1.25	void *ptr = salloc_ (n);
490	root	1.23
491	root	1.24	if (src)
492	root	1.25	memcpy (ptr, src, n);
493	root	1.24	else
494	root	1.25	memset (ptr, 0, n);
495	root	1.23
496			return ptr;
497	root	1.3	}
498	root	1.11
499	root	1.69	/******************************************************************************/
500
501			#ifdef DEBUG_SALLOC
502
503	root	1.70	#define MAGIC 0xa1b2c35543deadLL
504	root	1.69
505			void *g_slice_alloc (unsigned long size)
506			{
507			unsigned long p = (unsigned long ) (g_slice_alloc)(size + sizeof (unsigned long));
508			*p++ = size ^ MAGIC;
509			//fprintf (stderr, "g_slice_alloc %ld %p\n", size, p);//D
510			return (void *)p;
511			}
512
513			void *g_slice_alloc0 (unsigned long size)
514			{
515			return memset (g_slice_alloc (size), 0, size);
516			}
517
518			void g_slice_free1 (unsigned long size, void *ptr)
519			{
520			if (expect_true (ptr))
521			{
522			//fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D
523			unsigned long p = (unsigned long )ptr;
524			unsigned long s = *--p ^ MAGIC;
525
526			if ((*p ^ MAGIC) != size)
527			LOG (logBacktrace \| llevError, "slice free size (%lx) doesn't match alloc size (%lx)\n", size, s);
528
529			*p = MAGIC;
530
531			(g_slice_free1)(s + sizeof (unsigned long), p);
532			}
533			}
534
535			#endif
536
537			/******************************************************************************/
538
539	root	1.11	void assign (char dst, const char src, int maxlen)
540			{
541			if (!src)
542			src = "";
543
544			int len = strlen (src);
545
546			if (len >= maxlen - 1)
547			{
548			if (maxlen <= 4)
549			{
550			memset (dst, '.', maxlen - 1);
551			dst [maxlen - 1] = 0;
552			}
553			else
554			{
555			memcpy (dst, src, maxlen - 4);
556			memcpy (dst + maxlen - 4, "...", 4);
557			}
558			}
559			else
560			memcpy (dst, src, len + 1);
561			}
562
563	root	1.65	const char *
564	root	1.51	format (const char *format, ...)
565			{
566	root	1.65	static dynbuf_text buf;
567	root	1.51
568	root	1.65	buf.clear ();
569	root	1.51
570	root	1.65	va_list ap;
571			va_start (ap, format);
572			buf.vprintf (format, ap);
573			va_end (ap);
574
575			return buf;
576	root	1.51	}
577
578	root	1.23	tstamp now ()
579			{
580			struct timeval tv;
581
582			gettimeofday (&tv, 0);
583			return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
584			}
585	root	1.17
586	root	1.32	int
587			similar_direction (int a, int b)
588			{
589			if (!a \|\| !b)
590			return 0;
591
592			int diff = (b - a) & 7;
593			return diff <= 1 \|\| diff >= 7;
594			}
595
596	root	1.48	/* crc32 0xdebb20e3 table and supplementary functions. */
597			extern const uint32_t crc_32_tab[256] =
598			{
599			0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
600			0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
601			0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
602			0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
603			0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
604			0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
605			0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
606			0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
607			0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
608			0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
609			0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
610			0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
611			0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
612			0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
613			0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
614			0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
615			0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
616			0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
617			0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
618			0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
619			0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
620			0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
621			0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
622			0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
623			0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
624			0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
625			0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
626			0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
627			0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
628			0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
629			0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
630			0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
631			0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
632			0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
633			0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
634			0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
635			0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
636			0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
637			0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
638			0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
639			0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
640			0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
641			0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
642			0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
643			0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
644			0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
645			0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
646			0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
647			0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
648			0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
649			0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
650			0x2d02ef8dL
651			};
652