--- deliantra/server/include/dynbuf.h 2007/05/28 21:15:56 1.11 +++ deliantra/server/include/dynbuf.h 2012/10/29 23:55:53 1.34 @@ -1,25 +1,25 @@ /* - * This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game. - * - * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team - * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team - * Copyright (©) 1992,2007 Frank Tore Johansen - * - * Crossfire TRT 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 2 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 Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51 - * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - * The authors can be reached via e-mail to + * This file is part of Deliantra, the Roguelike Realtime MMORPG. + * + * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team + * Copyright (©) 2002 Mark Wedel & Crossfire Development Team + * Copyright (©) 1992 Frank Tore Johansen + * + * 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 + * . + * + * The authors can be reached via e-mail to */ #ifndef DYNBUF_H__ @@ -28,6 +28,7 @@ #include #include +#include "compiler.h" #include "util.h" #include "shstr.h" @@ -49,37 +50,66 @@ }; char *ptr, *end; - int ext; int _size; + int extend, cextend; chunk *first, *last; - void _reserve (int size); - void _clear (); - void clear (); - void finish (); + void reserve (int size); + void init (int initial); // allocate sinitial chunk + void free (chunk *&chain); // free chain of chunks + char *_linearise (int extra = 0); + void finalise (); public: - dynbuf (int initial = 4096, int extend = 16384); - ~dynbuf (); + // initial - the size of the initial chunk to be allocated + // extend - first incremental step when buffer size exceeded + dynbuf (int initial = 4096, int extend = 16384) + : extend (extend) + { + init (initial); + } + + ~dynbuf () + { + free (first); + } + + // resets the dynbuf, but does not free the first chunk + // which is either of size "initial" or the size of the last + // linearise + void clear (); int size () const { return _size + (ptr - last->data); } bool empty () const { return !size (); } void linearise (void *data); - char *linearise (); // does not 0-terminate(!) + char *linearise () // does not 0-terminate(!) + { + return first->next ? _linearise () : first->data; + } int room () const { return end - ptr; } + // make sure we have "size" extra room char *force (int size) { - if (expect_false (ptr + size >= end)) - _reserve (size); + if (expect_false (ptr + size > end)) + reserve (size); + + assume (ptr + size <= end); return ptr; } + // used for force + alloc combo + void alloc (char *p) + { + ptr = p; + } + + // allocate size bytes and return pointer to them (caller must force()) char *falloc (int size) { char *res = ptr; @@ -87,6 +117,7 @@ return res; } + // allocate size bytes and return pointer to them char *alloc (int size) { force (size); @@ -116,18 +147,22 @@ add (s, strlen (s)); } - void add (const shstr &s) + void add (shstr_tmp s) { add (s.s, s.length ()); } + // rather inefficient + void splice (int offset, int olen, const char *s, int slen); + void splice (int offset, int olen) { splice (offset, olen, "", 0); } + //TODO //void add_destructive (dynbuf &buf); dynbuf &operator << (char c) { add (c); return *this; } dynbuf &operator << (unsigned char c) { return *this << char (c); } dynbuf &operator << (const char *s) { add (s); return *this; } - dynbuf &operator << (const shstr &s) { add (s); return *this; } + dynbuf &operator << (shstr_tmp s) { add (s); return *this; } dynbuf &operator << (const std::string &s) { add (s.data(), s.size ()); return *this; } operator std::string (); @@ -140,11 +175,38 @@ { } using dynbuf::add; - void add (sint32 i); void add (sint64 i); - void printf (const char *format, ...); + //TODO: should optimise the case printf "(name %+d)" as it comes up extremely often + + //using dynbuf::operator <<; // doesn't work, sometimes C++ just suxx + // instead we use an ugly template function + template + dynbuf_text &operator << (T c) { *(dynbuf *)this << c; return *this; } + + dynbuf_text &operator << (sint16 i) { add (sint32 (i)); return *this; } + dynbuf_text &operator << (uint16 i) { add (sint32 (i)); return *this; } + dynbuf_text &operator << (sint32 i) { add (sint32 (i)); return *this; } + dynbuf_text &operator << (sint64 i) { add (sint64 (i)); return *this; } + dynbuf_text &operator << (uint32 i) { add (sint64 (i)); return *this; } + dynbuf_text &operator << (uint64 i) { add (sint64 (i)); return *this; } + + void printf (const char *format, ...) attribute ((format (printf, 2, 3))); + void vprintf (const char *format, va_list ap); + + void add_abilities (const char *name, uint32 abilities); + void add_paths (const char *name, uint32 paths); + + // we need to redefine, to keep the API :/ + using dynbuf::splice; + void splice (int offset, int olen, const char *s) + { + dynbuf::splice (offset, olen, s, strlen (s)); + } + + // returns the string, linearised and with trailing \0 + operator char *(); }; #endif