[ViewVC] Diff of: cvs/deliantra/server/common/arch.C

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.17 by root, Tue Sep 12 19:20:06 2006 UTC vs.
Revision 1.22 by root, Thu Sep 14 22:35:53 2006 UTC

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-    The authors can be reached via e-mail at crossfire-devel@real-time.com
+    The authors can be reached via e-mail at <crossfire@schmorp.de>
 */
 #include <cassert>
 #include <tr1/unordered_map>
  * MSW 2003-04-29
  */
 #if USE_UNORDERED_MAP
 // the hashtable
-typedef
-  std::tr1::unordered_map <
+typedef std::tr1::unordered_map
-size_t, archetype *>
+  <
+    std::size_t,
+    archetype *,
+    std::hash<size_t>,
+    std::equal_to<size_t>,
+    slice_allocator< std::pair<const std::size_t, archetype *> >
+    true,
-  HT;
+  > HT;
-static
+static HT ht;
-  HT
-  ht;
 #endif
 /**
  * GROS -  This function retrieves an archetype given the name that appears
  * during the game (for example, "writing pen" instead of "stylus").
  * - the archetype found or null if nothing was found.
  */
 archetype *
 find_archetype_by_object_name (const char *name)
 {
-  archetype *
+  archetype *at;
-    at;
   if (name == NULL)
     return (archetype *) NULL;
   for (at = first_archetype; at != NULL; at = at->next)
  * except that it considers only items of the given type.
  */
 archetype *
 find_archetype_by_object_type_name (int type, const char *name)
 {
-  archetype *
+  archetype *at;
-    at;
   if (name == NULL)
     return NULL;
   for (at = first_archetype; at != NULL; at = at->next)
     {
       tmpname[i] = 0;
       at = find_archetype_by_object_name (tmpname);
       if (at != NULL)
-        {
-          return arch_to_object (at);
+        return arch_to_object (at);
-        }
     }
   return create_singularity (name);
 }
   * Last, make a check on the full name.
   */
 int
 item_matched_string (object *pl, object *op, const char *name)
 {
-  char *
-    cp,
-    local_name[MAX_BUF];
+  char *cp, local_name[MAX_BUF];
-  int
+  int count, retval = 0;
-    count,
-    retval = 0;
   strcpy (local_name, name);    /* strtok is destructive to name */
   for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
     {
 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 = find_archetype ("empty_archetype");
+  empty_archetype = archetype::find ("empty_archetype");
 /*  init_blocksview();*/
 }
 /*
  */
 void
 init_archetable (void)
 {
-  archetype *
+  archetype *at;
-    at;
   LOG (llevDebug, " Setting up archetable...\n");
   for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
     add_arch (at);
  */
 void
 dump_all_archetypes (void)
 {
-  archetype *
+  archetype *at;
-    at;
   for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
     {
       dump_arch (at);
       fprintf (logfile, "%s\n", errmsg);
 }
 void
 free_all_archs (void)
 {
-  archetype *
+  archetype *at, *next;
-  at, *
-    next;
-  int
-    i = 0, f = 0;
+  int i = 0, f = 0;
   for (at = first_archetype; at != NULL; at = next)
     {
       if (at->more)
         next = at->more;
  * of archetype-structures.
  */
 void
 first_arch_pass (object_thawer & fp)
 {
-  archetype *
-  at, *
-    head = NULL, *last_more = NULL;
+  archetype *at, *head = NULL, *last_more = NULL;
   at->clone.arch = first_archetype = at = new archetype;
   while (int i = load_object (fp, &at->clone, 0))
     {
  */
 void
 second_arch_pass (object_thawer & thawer)
 {
-  char
-  buf[MAX_BUF], *
-    variable = buf, *argument, *cp;
+  char buf[MAX_BUF], *variable = buf, *argument, *cp;
-  archetype *
-    at = NULL, *other;
+  archetype *at = NULL, *other;
   while (fgets (buf, MAX_BUF, thawer) != NULL)
     {
       if (*buf == '#')
         continue;
               cp--;
             }
         }
       if (!strcmp ("Object", variable))
         {
-          if ((at = find_archetype (argument)) == NULL)
+          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 = find_archetype (argument)) == 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;
             }
         }
 #ifdef DEBUG
 void
 check_generators (void)
 {
-  archetype *
+  archetype *at;
-    at;
   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);
 }
  */
 void
 load_archetypes (void)
 {
-  char
-    filename[MAX_BUF];
+  char filename[MAX_BUF];
 #if TIME_ARCH_LOAD
   struct timeval
     tv1,
     tv2;
  */
 object *
 arch_to_object (archetype *at)
 {
-  object *
+  object *op;
-    op;
   if (at == NULL)
     {
       if (warn_archetypes)
         LOG (llevError, "Couldn't find archetype.\n");
  */
 object *
 create_singularity (const char *name)
 {
-  object *
+  object *op;
-    op;
-  char
-    buf[MAX_BUF];
+  char buf[MAX_BUF];
   sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
   op = get_object ();
   op->name = op->name_pl = buf;
   SET_FLAG (op, FLAG_NO_PICK);
  */
 object *
 get_archetype (const char *name)
 {
-  archetype *
+  archetype *at = archetype::find (name);
-    at;
-  at = find_archetype (name);
+  if (!at)
-  if (at == NULL)
     return create_singularity (name);
   return arch_to_object (at);
 }
  */
 unsigned long
 hasharch (const char *str, int tablesize)
 {
-  unsigned long
+  unsigned long hash = 0;
-    hash = 0;
-  unsigned int
+  unsigned int i = 0;
-    i = 0;
-  const char *
+  const char *p;
-    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
  * Finds, using the hashtable, which archetype matches the given name.
  * returns a pointer to the found archetype, otherwise NULL.
  */
 archetype *
-find_archetype (const char *name)
+archetype::find (const char *name)
 {
-#if USE_UNORDERED_MAP
-  name = shstr::find (name);
   if (!name)
     return 0;
-  HT::const_iterator i = ht.find ((size_t) name);
+#if USE_UNORDERED_MAP
+  AUTODECL (i, ht.find ((size_t) name));
   if (i == ht.end ())
     return 0;
   else
     return i->second;
 #endif
-  archetype *
+  archetype *at;
-    at;
-  unsigned long
+  unsigned long index;
-    index;
-  if (name == NULL)
-    return (archetype *) NULL;
   index = hasharch (name, ARCHTABLE);
   arch_search++;
   for (;;)
     {
       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;
     }
 }
 {
 #if USE_UNORDERED_MAP
   ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
 #endif
-  int
-    index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
+  int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
   for (;;)
     {
       if (arch_table[index] == NULL)
         {
  */
 archetype *
 type_to_archetype (int type)
 {
-  archetype *
+  archetype *at;
-    at;
-  for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
+  for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
     if (at->clone.type == type)
       return at;
-  return NULL;
+  return 0;
 }
 /*
  * Returns a new object copied from the first archetype matching
  * the given type.
  */
 object *
 clone_arch (int type)
 {
-  archetype *
+  archetype *at;
-    at;
-  object *
-    op = get_object ();
+  object *op = get_object ();
   if ((at = type_to_archetype (type)) == NULL)
     {
       LOG (llevError, "Can't clone archetype %d\n", type);
       free_object (op);
       return NULL;
     }
   copy_object (&at->clone, op);
   op->instantiate ();
   return op;
 }
  */
 object *
 object_create_arch (archetype *at)
 {
-  object *
+  object *op, *prev = 0, *head = 0;
-  op, *
-    prev = NULL, *head = NULL;
   while (at)
     {
       op = arch_to_object (at);
       op->x = at->clone.x;
       op->y = at->clone.y;
       if (head)
         op->head = head, prev->more = op;
       if (!head)
         head = op;
       prev = op;
       at = at->more;
     }
   return (head);
 }
-/*** end of arch.c ***/

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/common/arch.C (file contents): Revision 1.17 by root, Tue Sep 12 19:20:06 2006 UTC vs. Revision 1.22 by root, Thu Sep 14 22:35:53 2006 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.17 by root, Tue Sep 12 19:20:06 2006 UTC vs.
Revision 1.22 by root, Thu Sep 14 22:35:53 2006 UTC