--- deliantra/server/common/arch.C	2007/01/15 21:06:18	1.37
+++ deliantra/server/common/arch.C	2007/04/17 10:06:32	1.52
@@ -28,16 +28,8 @@
 #include <funcpoint.h>
 #include <loader.h>
 
-#define USE_UNORDERED_MAP 0
-
-#if USE_UNORDERED_MAP
-# include <tr1/functional>
-# include <tr1/unordered_map>
-#endif
-
-int arch_cmp = 0;               /* How many strcmp's */
-int arch_search = 0;            /* How many searches */
-int arch_init;                  /* True if doing arch initialization */
+#include <tr1/functional>
+#include <tr1/unordered_map>
 
 /* The naming of these functions is really poor - they are all
  * pretty much named '.._arch_...', but they may more may not
@@ -47,22 +39,20 @@
  * MSW 2003-04-29
  */
 
-#if USE_UNORDERED_MAP
+bool loading_arch; // ugly flag to object laoder etc. to suppress/request special processing
+
 // the hashtable
 typedef std::tr1::unordered_map
   <
-    std::size_t,
+    const char *,
     arch_ptr,
-    std::tr1::hash<size_t>,
-    std::equal_to<size_t>,
-    slice_allocator< std::pair<const std::size_t, archetype *> >
-    true,
+    str_hash,
+    str_equal,
+    slice_allocator< std::pair<const char *const, arch_ptr> >
   > HT;
 
-static HT ht;
-#else
-static arch_ptr arch_table[ARCHTABLE];
-#endif
+static HT ht (5000);
+static std::vector<archetype *> archetypes;
 
 /**
  * GROS -  This function retrieves an archetype given the name that appears
@@ -78,17 +68,13 @@
 archetype *
 find_archetype_by_object_name (const char *name)
 {
-  archetype *at;
+  shstr_cmp name_cmp (name);
 
-  if (name == NULL)
-    return (archetype *) NULL;
+  for (archetype *at = first_archetype; at; at = at->next)
+    if (at->clone.name == name_cmp)
+      return at;
 
-  for (at = first_archetype; at != NULL; at = at->next)
-    {
-      if (!strcmp (at->clone.name, name))
-        return at;
-    }
-  return NULL;
+  return 0;
 }
 
 /**
@@ -99,18 +85,13 @@
 archetype *
 find_archetype_by_object_type_name (int type, const char *name)
 {
-  archetype *at;
-
-  if (name == NULL)
-    return NULL;
+  shstr_cmp name_cmp (name);
 
-  for (at = first_archetype; at != NULL; at = at->next)
-    {
-      if (at->clone.type == type && strcmp (at->clone.name, name) == 0)
-        return at;
-    }
+  for (archetype *at = first_archetype; at; at = at->next)
+    if (at->clone.name == name_cmp && at->clone.type == type)
+      return at;
 
-  return NULL;
+  return 0;
 }
 
 /* This is a lot like the above function.  Instead, we are trying to match
@@ -121,12 +102,11 @@
 object *
 get_archetype_by_skill_name (const char *skill, int type)
 {
-  archetype *at;
+  shstr_cmp skill_cmp (skill);
 
-  if (skill)
-    for (at = first_archetype; at; at = at->next)
-      if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
-        return arch_to_object (at);
+  for (archetype *at = first_archetype; at; at = at->next)
+    if (at->clone.skill == skill_cmp && (type == -1 || type == at->clone.type))
+      return arch_to_object (at);
 
   return 0;
 }
@@ -141,15 +121,11 @@
 archetype *
 get_archetype_by_type_subtype (int type, int subtype)
 {
-  archetype *
-    at;
+  for (archetype *at = first_archetype; at; at = at->next)
+    if ((type == -1 || type == at->clone.type) && (subtype == -1 || subtype == at->clone.subtype))
+      return at;
 
-  for (at = first_archetype; at != NULL; at = at->next)
-    {
-      if (((type == -1) || (type == at->clone.type)) && (subtype == -1 || subtype == at->clone.subtype))
-        return at;
-    }
-  return NULL;
+  return 0;
 }
 
 /**
@@ -167,7 +143,6 @@
 object *
 get_archetype_by_object_name (const char *name)
 {
-  archetype *at;
   char tmpname[MAX_BUF];
   int i;
 
@@ -176,9 +151,8 @@
   for (i = strlen (tmpname); i > 0; i--)
     {
       tmpname[i] = 0;
-      at = find_archetype_by_object_name (tmpname);
 
-      if (at)
+      if (archetype *at = find_archetype_by_object_name (tmpname))
         return arch_to_object (at);
     }
 
@@ -208,7 +182,7 @@
   char *cp, local_name[MAX_BUF];
   int count, retval = 0;
 
-  strcpy (local_name, name);    /* strtok is destructive to name */
+  assign (local_name, name);    /* strtok is destructive to name */
 
   for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
     {
@@ -303,286 +277,201 @@
   return 0;
 }
 
-/*
- * Initialises the internal linked list of archetypes (read from file).
- * Then the global "empty_archetype" pointer is initialised.
- * Then the blocksview[] array is initialised.
- */
-
-void
-init_archetypes (void)
-{                               /* called from add_player() and edit() */
-  if (first_archetype != NULL)  /* Only do this once */
-    return;
-
-  arch_init = 1;
-  load_archetypes ();
-  arch_init = 0;
-  empty_archetype = archetype::find ("empty_archetype");
+archetype::archetype ()
+{
+  clone.arch = this;
 
-/*  init_blocksview();*/
+  CLEAR_FLAG (&clone, FLAG_FREED);      /* This shouldn't matter, since copy_to */
+  SET_FLAG (&clone, FLAG_REMOVED);      /* doesn't copy these flags... */
 }
 
-/*
- * Stores debug-information about how efficient the hashtable
- * used for archetypes has been in the static errmsg array.
- */
-
-void
-arch_info (object *op)
+archetype::~archetype ()
 {
-  sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
-  new_draw_info (NDI_BLACK, 0, op, errmsg);
+  //TODO: nuke ->more's
 }
 
-/*
- * Initialise the hashtable used by the archetypes.
- */
-
-void
-clear_archetable (void)
+static void
+unlink (archetype *at)
 {
-  memset ((void *) arch_table, 0, ARCHTABLE * sizeof (archetype *));
-}
+  if (at->head)
+    at = at->head;
 
-/*
- * An alternative way to init the hashtable which is slower, but _works_...
- */
+  // destroy this archetype's link, making singletons out of its parts
+  while (at)
+    {
+      archetype *more = at->more;
+      at->clone.destroy_inv ();
+      at->head = at->more = 0;
+      at = more;
+    }
+}
 
+// dire hack, need to rationalise
 void
-init_archetable (void)
+overwrite (archetype *at, object *op)
 {
-  archetype *at;
-
-  LOG (llevDebug, " Setting up archetable...\n");
+  at->clone = *op;
+  
+  at->clone.arch = at;
+  at->clone.inv = op->inv; op->inv = 0;
 
-  for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
-    at->hash_add ();
-
-  LOG (llevDebug, "done\n");
+  op->destroy ();
 }
 
-void
-free_all_archs (void)
+bool
+archetype::load (object_thawer &f)
 {
-  archetype *at, *next;
-  int i = 0, f = 0;
+  assert (f.kw == KW_object);
 
-  for (at = first_archetype; at != NULL; at = next)
-    {
-      if (at->more)
-        next = at->more;
-      else
-        next = at->next;
+  typedef std::pair<archetype *, object *> part;
+  std::vector<part> parts;
 
-      delete
-        at;
+  coroapi::cede_to_tick_every (100);
 
-      i++;
-    }
-
-  LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
-}
+  for (;;)
+    {
+      archetype *at = get (f.get_str ());
+      object *op = object::create ();
 
-archetype::archetype ()
-{
-  CLEAR_FLAG (&clone, FLAG_FREED);      /* This shouldn't matter, since copy_to */
-  SET_FLAG (&clone, FLAG_REMOVED);      /* doesn't copy these flags... */
-}
+      if (!op->parse_kv (f))
+        goto fail;
 
-archetype::~archetype ()
-{
-}
+      parts.push_back (std::make_pair (at, op));
 
-/*
- * Reads/parses the archetype-file, and copies into a linked list
- * of archetype-structures.
- */
-void
-first_arch_pass (object_thawer & fp)
-{
-  archetype *head = 0, *last_more = 0;
+      if (f.kw != KW_more)
+        break;
 
-  archetype *at = new archetype;
-  at->clone.arch = first_archetype = at;
+      f.next ();
+      assert (f.kw == KW_object);
+    }
 
-  while (int i = load_object (fp, &at->clone, 0))
-    {
-      at->clone.speed_left = (float) (-0.1);
-      /* copy the body_info to the body_used - this is only really
-       * need for monsters, but doesn't hurt to do it for everything.
-       * by doing so, when a monster is created, it has good starting
-       * values for the body_used info, so when items are created 
-       * for it, they can be properly equipped.
-       */
-      memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
+  {
+    archetype *head = parts.front ().first;
 
-      switch (i)
-        {
-            case LL_NORMAL:    /* A new archetype, just link it with the previous */
-              if (last_more != NULL)
-                last_more->next = at;
-              if (head != NULL)
-                head->next = at;
-              head = last_more = at;
-#if 0
-              if (!op->type)
-                LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
-#endif
-              at->tail_x = 0;
-              at->tail_y = 0;
-              break;
-
-            case LL_MORE:      /* Another part of the previous archetype, link it correctly */
-
-              at->head = head;
-              at->clone.head = &head->clone;
-              if (last_more != NULL)
-                {
-                  last_more->more = at;
-                  last_more->clone.more = &at->clone;
-                }
-              last_more = at;
-
-              /* If this multipart image is still composed of individual small
-               * images, don't set the tail_.. values.  We can't use them anyways,
-               * and setting these to zero makes the map sending to the client much
-               * easier as just looking at the head, we know what to do.
-               */
-              if (at->clone.face != head->clone.face)
-                {
-                  head->tail_x = 0;
-                  head->tail_y = 0;
-                }
-              else
-                {
-                  if (at->clone.x > head->tail_x)
-                    head->tail_x = at->clone.x;
-                  if (at->clone.y > head->tail_y)
-                    head->tail_y = at->clone.y;
-                }
-              break;
+    // check that all archetypes belong to the same object or are heads
+    for (auto (p, parts.begin ()); p != parts.end (); ++p)
+      {
+        archetype *at = p->first;
+
+        if (at->head != head && at->head)
+          {
+            LOG (llevError, "%s: unable to overwrite foreign non-head archetype with non-head archetype\n", &at->name);
+            goto fail;
+          }
+
+        if (at->next && at != head)
+          {
+            LOG (llevError, "%s: unable to overwrite foreign head archetype with non-head archetype\n", &at->name);
+            goto fail;
+          }
+      }
+
+    // sever chain of existing head object
+    for (archetype *more, *at = head; at; at = more)
+      {
+        more = at->more;
+
+        at->head = 0;
+        at->more = 0;
+      }
+
+    // replace/update head
+    overwrite (head, parts.front ().second);
+    head->tail_x = 0;
+    head->tail_y = 0;
+
+    // link into list of heads, if not already there
+    if (!head->linked)
+      {
+        head->linked = true;
+        head->next = first_archetype;
+        first_archetype = head;
+      }
+
+    // reassemble new chain
+    archetype *prev = head;
+    for (auto (p, parts.begin () + 1); p != parts.end (); ++p)
+      {
+        archetype *at = p->first;
+        overwrite (at, p->second);
+
+        if (at->clone.x > head->tail_x) head->tail_x = at->clone.x;
+        if (at->clone.y > head->tail_y) head->tail_y = at->clone.y;
+
+        at->head         = head;
+        at->clone.head   = &head->clone;
+        prev->more       = at;
+        prev->clone.more = &at->clone;
 
-        }
+        prev = at;
+      }
+  }
 
-      at = new archetype;
+  return true;
 
-      at->clone.arch = at;
-    }
+fail:
+  for (auto (p, parts.begin ()); p != parts.end (); ++p)
+    p->second->destroy (true);
 
-  delete at;
+  return false;
 }
 
 /*
- * Reads the archetype file once more, and links all pointers between
- * archetypes.
+ * Reads/parses the archetype-file, and copies into a linked list
+ * of archetype-structures.
  */
-
-void
-second_arch_pass (object_thawer & thawer)
+static bool
+load_archetypes (object_thawer &f)
 {
-  char buf[MAX_BUF], *variable = buf, *argument, *cp;
-  archetype *at = NULL, *other;
-
-  while (fgets (buf, MAX_BUF, thawer) != NULL)
+  for (;;)
     {
-      if (*buf == '#')
-        continue;
-      if ((argument = strchr (buf, ' ')) != NULL)
-        {
-          *argument = '\0', argument++;
-          cp = argument + strlen (argument) - 1;
-          while (isspace (*cp))
-            {
-              *cp = '\0';
-              cp--;
-            }
-        }
-      if (!strcmp ("Object", variable))
+      switch (f.kw)
         {
-          if ((at = archetype::find (argument)) == NULL)
-            LOG (llevError, "Warning: failed to find arch %s\n", argument);
-        }
-      else if (!strcmp ("other_arch", variable))
-        {
-          if (at != NULL && at->clone.other_arch == NULL)
-            {
-              if ((other = archetype::find (argument)) == NULL)
-                LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
-              else if (at != NULL)
-                at->clone.other_arch = other;
-            }
-        }
-      else if (!strcmp ("randomitems", variable))
-        {
-          if (at != NULL)
-            {
-              treasurelist *tl = find_treasurelist (argument);
-
-              if (tl == NULL)
-                LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
-              else
-                at->clone.randomitems = tl;
-            }
-        }
-    }
-}
+          case KW_object:
+            loading_arch = true;
+            if (!archetype::load (f))
+              {
+                loading_arch = false;
+                return false;
+              }
 
-#ifdef DEBUG
-void
-check_generators (void)
-{
-  archetype *at;
+            loading_arch = false;
+            continue;
+
+          case KW_EOF:
+            return true;
 
-  for (at = first_archetype; at != NULL; at = at->next)
-    if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
-      LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
+          default:
+            if (!f.parse_error ("archetypes file"))
+              return false;
+        }
+
+        f.next ();
+    }
 }
-#endif
 
 /*
  * First initialises the archtype hash-table (init_archetable()).
  * Reads and parses the archetype file (with the first and second-pass
  * functions).
- * Then initialises treasures by calling load_treasures().
  */
-
-void
-load_archetypes (void)
+bool
+load_archetype_file (const char *filename)
 {
-  char filename[MAX_BUF];
+  object_thawer f (filename);
 
-  sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
-  LOG (llevDebug, "Reading archetypes from %s:\n", filename);
+  f.next ();
 
-  {
-    object_thawer
-    thawer (filename);
+  if (!load_archetypes (f))
+    return false;
 
-    clear_archetable ();
-    LOG (llevDebug, " arch-pass 1...\n");
-    first_arch_pass (thawer);
-    LOG (llevDebug, " done\n");
-  }
-
-  init_archetable ();
   warn_archetypes = 1;
 
-  {
-    object_thawer
-    thawer (filename);
+  empty_archetype = archetype::find ("empty_archetype");
+  if (!empty_archetype)
+    return false;
 
-    LOG (llevDebug, " loading treasure...\n");
-    load_treasures ();
-    LOG (llevDebug, " done\n");
-    LOG (llevDebug, " arch-pass 2...\n");
-    second_arch_pass (thawer);
-    LOG (llevDebug, " done\n");
-#ifdef DEBUG
-    check_generators ();
-#endif
-  }
-  LOG (llevDebug, " done\n");
+  return true;
 }
 
 /*
@@ -592,9 +481,7 @@
 object *
 arch_to_object (archetype *at)
 {
-  object *op;
-
-  if (at == NULL)
+  if (!at)
     {
       if (warn_archetypes)
         LOG (llevError, "Couldn't find archetype.\n");
@@ -602,7 +489,7 @@
       return NULL;
     }
 
-  op = at->clone.clone ();
+  object *op = at->clone.clone ();
   op->arch = at;
   op->instantiate ();
   return op;
@@ -643,80 +530,36 @@
 }
 
 /*
- * Hash-function used by the arch-hashtable.
- */
-
-unsigned long
-hasharch (const char *str, int tablesize)
-{
-  unsigned long hash = 0;
-  unsigned int i = 0;
-  const char *p;
-
-  /* use the one-at-a-time hash function, which supposedly is
-   * better than the djb2-like one used by perl5.005, but
-   * certainly is better then the bug used here before.
-   * see http://burtleburtle.net/bob/hash/doobs.html
-   */
-  for (p = str; i < MAXSTRING && *p; p++, i++)
-    {
-      hash += *p;
-      hash += hash << 10;
-      hash ^= hash >> 6;
-    }
-
-  hash += hash << 3;
-  hash ^= hash >> 11;
-  hash += hash << 15;
-
-  return hash % tablesize;
-}
-
-/*
  * Finds, using the hashtable, which archetype matches the given name.
  * returns a pointer to the found archetype, otherwise NULL.
  */
-
 archetype *
 archetype::find (const char *name)
 {
   if (!name)
     return 0;
 
-#if USE_UNORDERED_MAP
-  AUTODECL (i, ht.find ((size_t) name));
+  auto (i, ht.find (name));
 
   if (i == ht.end ())
     return 0;
   else
     return i->second;
-#endif
+}
 
-  archetype *at;
-  unsigned long index;
+archetype *
+archetype::get (const char *name)
+{
+  archetype *at = find (name);
 
-  index = hasharch (name, ARCHTABLE);
-  arch_search++;
-  for (;;)
+  if (!at)
     {
-      at = arch_table[index];
-
-      if (at == NULL)
-        {
-          if (warn_archetypes)
-            LOG (llevError, "Couldn't find archetype %s\n", name);
-
-          return NULL;
-        }
-
-      arch_cmp++;
-
-      if (!strcmp ((const char *) at->name, name))
-        return at;
-
-      if (++index >= ARCHTABLE)
-        index = 0;
+      archetypes.push_back (at = new archetype);
+      at->name = name;
+      at->hash_add ();
     }
+
+  return at;
 }
 
 /*
@@ -725,66 +568,23 @@
 void
 archetype::hash_add ()
 {
-#if USE_UNORDERED_MAP
-  ht.insert (std::make_pair ((size_t) (const char *) name, this));
-#else
-
-  int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
-
-  for (;;)
-    {
-      if (!arch_table[index])
-        {
-          arch_table[index] = this;
-          break;
-        }
-
-      if (++index == ARCHTABLE)
-        index = 0;
-
-      if (index == org_index)
-        fatal (ARCHTABLE_TOO_SMALL);
-    }
-#endif
+  ht.insert (std::make_pair (name, this));
 }
 
 void
 archetype::hash_del ()
 {
-#if USE_UNORDERED_MAP
-# error remove this from HT
-#else
-
-  int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
-
-  for (;;)
-    {
-      if (arch_table[index] == this)
-        {
-          arch_table[index] = 0;
-          break;
-        }
-
-      if (++index == ARCHTABLE)
-        index = 0;
-
-      if (index == org_index)
-        break;
-    }
-#endif
+  ht.erase (name);
 }
 
 /*
  * Returns the first archetype using the given type.
  * Used in treasure-generation.
  */
-
 archetype *
 type_to_archetype (int type)
 {
-  archetype *at;
-
-  for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
+  for (archetype *at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
     if (at->clone.type == type)
       return at;
 
@@ -796,7 +596,6 @@
  * the given type.
  * Used in treasure-generation.
  */
-
 object *
 clone_arch (int type)
 {