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

Comparing deliantra/server/server/dynbuf.C (file contents):
Revision 1.12 by root, Sun May 27 22:57:43 2007 UTC vs.
Revision 1.31 by root, Fri Mar 26 01:04:45 2010 UTC

+/*
+ * This file is part of Deliantra, the Roguelike Realtime MMORPG.
+ *
+ * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ *
+ * Deliantra is free software: you can redistribute it and/or modify it under
+ * the terms of the Affero 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 Affero GNU General Public License
+ * and 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>
+ */
 #include "global.h"
 #include <cstdio>
-dynbuf::dynbuf (int initial, int extend)
+void
+dynbuf::init (int initial)
 {
-  ext = extend;
+  cextend = extend;
   _size = 0;
   first = last = (chunk *)salloc<char> (sizeof (chunk) + initial);
   first->alloc = sizeof (chunk) + initial;
   first->next = 0;
   ptr = first->data;
   end = ptr + initial;
 }
-dynbuf::~dynbuf ()
+// frees a full chain and sets the pointer to zero
-{
-  _clear ();
-}
 void
-dynbuf::_clear ()
+dynbuf::free (chunk *&chain)
 {
-  while (first)
+  while (chain)
     {
-      chunk *next = first->next;
+      chunk *next = chain->next;
-      sfree<char> ((char *)first, first->alloc);
+      sfree<char> ((char *)chain, chain->alloc);
-      first = next;
+      chain = next;
     }
 }
 void
 dynbuf::clear ()
 {
-  _clear ();
+  cextend = extend;
+  free (first->next);
   _size = 0;
-  first = last = (chunk *)salloc<char> (sizeof (chunk) + ext);
-  first->alloc = sizeof (chunk) + ext;
-  first->next = 0;
   ptr = first->data;
-  end = ptr + ext;
+  end = ptr + first->alloc - sizeof (chunk);
+  last = first;
 }
 void
-dynbuf::finish ()
+dynbuf::finalise ()
 {
   // finalise current chunk
   _size += last->size = ptr - last->data;
 }
 void
-dynbuf::_reserve (int size)
+dynbuf::reserve (int size)
 {
-  finish ();
+  finalise ();
   do
     {
-      ext += ext >> 1;
+      cextend += cextend >> 1;
-      ext = (ext + 15) & ~15;
+      cextend = (cextend + 15) & ~15;
     }
-  while (ext < size);
+  while (cextend < size);
-  chunk *add = (chunk *) salloc<char> (sizeof (chunk) + ext);
+  chunk *add = (chunk *) salloc<char> (sizeof (chunk) + cextend);
-  add->alloc = sizeof (chunk) + ext;
+  add->alloc = sizeof (chunk) + cextend;
   add->next = 0;
   last->next = add;
   last = add;
   ptr = last->data;
-  end = ptr + ext;
+  end = ptr + cextend;
 }
 void
 dynbuf::linearise (void *data)
 {
       data = (void *)(((char *)data) + c->size);
     }
 }
 char *
-dynbuf::linearise ()
+dynbuf::_linearise (int extra)
 {
-  if (first->next)
+  finalise ();
-    {
-      finish ();
-      chunk *add = (chunk *) salloc<char> (sizeof (chunk) + _size);
+  chunk *add = (chunk *) salloc<char> (sizeof (chunk) + _size + extra);
-      add->alloc = sizeof (chunk) + _size;
+  add->alloc = sizeof (chunk) + _size;
-      add->next = 0;
+  add->next = 0;
-      linearise ((void *)add->data);
+  linearise ((void *)add->data);
-      _clear ();
+  free (first);
-      first = last = add;
+  first = last = add;
-      ptr = last->data + _size;
+  ptr = last->data + _size;
-      end = ptr;
+  end = ptr + extra;
-      _size = 0;
+  _size = 0;
-    }
   return first->data;
 }
 dynbuf::operator std::string ()
   // could optimise
   return std::string (linearise (), size ());
 }
 void
+dynbuf::splice (int offset, int olen, const char *s, int slen)
+{
+  // how much bytes to extend (negative if shrinking)
+  int adjust = slen - olen;
+  // linearise, unless everything fits in the last chunk
+  if (offset < _size || room () < adjust)
+    _linearise (max (adjust, 0));
+  offset -= _size; // offset into chunk
+  // now move tail to final position
+  char *pos = last->data + offset;
+  char *src = pos + olen;
+  char *dst = pos + slen;
+  memmove (dst, src, ptr - src);
+  // now copy new content
+  memcpy (pos, s, slen);
+  // finally adjust length
+  ptr += adjust;
+}
+void
-dynbuf_text::printf (const char *format, ...)
+dynbuf_text::vprintf (const char *format, va_list ap)
 {
   int len;
   {
     force (128);
-    va_list ap;
+    va_list apc;
-    va_start (ap, format);
+    va_copy (apc, ap);
-    len = vsnprintf (ptr, end - ptr, format, ap);
+    len = vsnprintf (ptr, end - ptr, format, apc);
-    va_end (ap);
+    va_end (apc);
     assert (len >= 0); // shield against broken vsnprintf's
     // was enough room available
     if (ptr + len < end)
       {
-        alloc (len);
+        ptr += len;
         return;
       }
   }
   // longer, try harder
+  vsnprintf (force (len + 1), len + 1, format, ap);
+  ptr += len;
+}
+void
+dynbuf_text::printf (const char *format, ...)
+{
   va_list ap;
   va_start (ap, format);
-  vsnprintf (force (len + 1), len + 1, format, ap);
+  vprintf (format, ap);
   va_end (ap);
-  alloc (len);
 }
 // simply return a mask with "bits" bits set
-inline uint64
+static inline uint64
 m (int b)
 {
   return (uint64 (1) << b) - 1;
 }
 // convert 9 digits to ascii, using only a single multiplication
 // (depending on cpu and compiler).
 // will generate a single 0 as output when v=lz=0
-inline char *
+static inline char *
 i2a_9 (char *ptr, uint32 v, bool lz)
 {
   // convert to 4.56 fixed-point representation
   // this should be optimal on 64 bit cpus, and rather
   // slow on 32 bit cpus. go figure :)
 }
 void
 dynbuf_text::add (sint32 i)
 {
-  force (11); // 10 digits + '-'
+  force (sint32_digits);
   *ptr = '-'; ptr += i < 0 ? 1 : 0;
   uint32 u = i < 0 ? -i : i;
   if (expect_true (u < 10)) // we have a lot of single-digit numbers, so optimise
-    fadd (char (u + '0'));
+    *ptr++ = u + '0';
+  else if (expect_true (u < 100)) // we have a lot of double-digit numbers, too :)
+    {
+      // let the compiler figure out sth. efficient here
+      *ptr++ = u / 10 + '0';
+      *ptr++ = u % 10 + '0';
+    }
   else if (expect_true (u < 1000000000)) // 9 0's
     ptr = i2a_9 (ptr, u, false);
   else
     {
-      sint32 div = u / 1000000000;
+      uint32 div = u / 1000000000;
       uint32 rem = u % 1000000000;
       ptr = i2a_9 (ptr, div, false);
       ptr = i2a_9 (ptr, rem, true);
     }
 }
 void
 dynbuf_text::add (sint64 i)
 {
-  force (20); // 19 digits + '-'
+  force (sint64_digits);
   *ptr = '-'; ptr += i < 0 ? 1 : 0;
   uint64 u = i < 0 ? -i : i;
   // split the number into a 1-digit part
   // (#19) and two 9 digit parts (9..18 and 0..8)
   // good compilers will only use multiplications here
   if (u < 10) // we have a lot of single-digit numbers, so optimise
-    fadd (char (u + '0'));
+    *ptr++ = u + '0';
   else if (expect_true (u < 1000000000)) // 9 0's
     ptr = i2a_9 (ptr, u, false);
   else if (expect_true (u < UINT64_C (1000000000000000000))) // 18 0's
     {
-      sint32 div = u / 1000000000;
+      uint32 div = u / 1000000000;
       uint32 rem = u % 1000000000;
       ptr = i2a_9 (ptr, div, false);
       ptr = i2a_9 (ptr, rem, true);
     }
   else
     {
-      // a biggy
+      // a biggy, split off the topmost digit
-      sint32 div = u / UINT64_C (1000000000000000000);
+      uint32 div = u / UINT64_C (1000000000000000000);
       uint64 rem = u % UINT64_C (1000000000000000000);
-      fadd (char (div + '0'));
+      *ptr++ = div + '0';
       u = rem;
       {
-        sint32 div = u / 1000000000;
+        uint32 div = u / 1000000000;
         uint32 rem = u % 1000000000;
         ptr = i2a_9 (ptr, div, true);
         ptr = i2a_9 (ptr, rem, true);
       }
     }
+}
+dynbuf_text::operator char *()
+{
+  *this << '\0';
+  linearise ();
+  --ptr;
+  return first->data;
+}
+void
+dynbuf_text::add_abilities (const char *name, uint32 abilities)
+{
+  if (!abilities)
+    return;
+  *this << '(' << name;
+  const char *sep = ": ";
+  for_all_bits_sparse_32 (abilities, i)
+    {
+      *this << sep; sep = ", ";
+      *this << attacks [i];
+    }
+  *this << ')';
+}
+void
+dynbuf_text::add_paths (const char *name, uint32 paths)
+{
+  if (!paths)
+    return;
+  *this << '(' << name;
+  const char *sep = ": ";
+  for (int i = 0; i < NRSPELLPATHS; ++i)
+    if (paths & (1 << i))
+      {
+        *this << sep; sep = ", ";
+        *this << spellpathnames [i];
+      }
+  *this << ')';
 }
 #if 0
 struct dynbuf_test_class {
   dynbuf_test_class ()
     exit (0);
   }
 } dynbuf_test;
 #endif

Diff Legend

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

Comparing deliantra/server/server/dynbuf.C (file contents): Revision 1.12 by root, Sun May 27 22:57:43 2007 UTC vs. Revision 1.31 by root, Fri Mar 26 01:04:45 2010 UTC

Diff Legend

Comparing deliantra/server/server/dynbuf.C (file contents):
Revision 1.12 by root, Sun May 27 22:57:43 2007 UTC vs.
Revision 1.31 by root, Fri Mar 26 01:04:45 2010 UTC