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

Comparing deliantra/server/server/dynbuf.C (file contents):
Revision 1.20 by root, Thu Nov 8 19:43:27 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * 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
+ * Deliantra is free software: you can redistribute it and/or modify it under
- * it under the terms of the GNU General Public License as published by
+ * the terms of the Affero GNU General Public License as published by the
- * the Free Software Foundation, either version 3 of the License, or
+ * Free Software Foundation, either version 3 of the License, or (at your
- * (at your option) any later version.
+ * 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
+ * You should have received a copy of the Affero GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ * 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>
 void
 dynbuf::init (int initial)
 {
+  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;
 }
+// frees a full chain and sets the pointer to zero
 void
 dynbuf::free (chunk *&chain)
 {
   while (chain)
     {
 }
 void
 dynbuf::clear ()
 {
+  cextend = extend;
   free (first->next);
   _size = 0;
   ptr = first->data;
   end = ptr + first->alloc - sizeof (chunk);
+  last = first;
 }
 void
 dynbuf::finalise ()
 {
 {
   finalise ();
   do
     {
-      extend += extend >> 1;
+      cextend += cextend >> 1;
-      extend = (extend + 15) & ~15;
+      cextend = (cextend + 15) & ~15;
     }
-  while (extend < size);
+  while (cextend < size);
-  chunk *add = (chunk *) salloc<char> (sizeof (chunk) + extend);
+  chunk *add = (chunk *) salloc<char> (sizeof (chunk) + cextend);
-  add->alloc = sizeof (chunk) + extend;
+  add->alloc = sizeof (chunk) + cextend;
   add->next = 0;
   last->next = add;
   last = add;
   ptr = last->data;
-  end = ptr + extend;
+  end = ptr + cextend;
 }
 void
 dynbuf::linearise (void *data)
 {
       data = (void *)(((char *)data) + c->size);
     }
 }
 char *
-dynbuf::_linearise ()
+dynbuf::_linearise (int extra)
 {
   finalise ();
-  chunk *add = (chunk *) salloc<char> (sizeof (chunk) + _size);
+  chunk *add = (chunk *) salloc<char> (sizeof (chunk) + _size + extra);
   add->alloc = sizeof (chunk) + _size;
   add->next = 0;
   linearise ((void *)add->data);
   free (first);
   first = last = add;
   ptr = last->data + _size;
-  end = ptr;
+  end = ptr + extra;
   _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::vprintf (const char *format, va_list ap)
 {
   vprintf (format, ap);
   va_end (ap);
 }
 // 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 :)
   *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);
     }
   // (#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 const char *()
+dynbuf_text::operator char *()
 {
   *this << '\0';
   linearise ();
   --ptr;
   return first->data;
     return;
   *this << '(' << name;
   const char *sep = ": ";
-  for (int i = 0; i < NROFATTACKS; ++i)
+  for_all_bits_sparse_32 (abilities, i)
-    if (abilities & (1 << i))
-      {
+    {
-        *this << sep; sep = ", ";
+      *this << sep; sep = ", ";
-        *this << attacks [i];
+      *this << attacks [i];
-      }
+    }
   *this << ')';
 }
 void

Diff Legend

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

Comparing deliantra/server/server/dynbuf.C (file contents): Revision 1.20 by root, Thu Nov 8 19:43:27 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.20 by root, Thu Nov 8 19:43:27 2007 UTC vs.
Revision 1.31 by root, Fri Mar 26 01:04:45 2010 UTC