ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/include/dynbuf.h
(Generate patch)

Comparing deliantra/server/include/dynbuf.h (file contents):
Revision 1.24 by root, Thu Oct 15 22:50:42 2009 UTC vs.
Revision 1.29 by root, Wed Nov 11 23:27:57 2009 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the 9 * the terms of the Affero GNU General Public License as published by the
… …
23 */ 23 */
24 24
25#ifndef DYNBUF_H__ 25#ifndef DYNBUF_H__
26#define DYNBUF_H__ 26#define DYNBUF_H__
27 27
28#include <cstdarg>
29#include <cstring> 28#include <cstring>
30#include <cassert> 29#include <cassert>
31 30
31#include "compiler.h"
32#include "util.h" 32#include "util.h"
33#include "shstr.h" 33#include "shstr.h"
34 34
35// this is a "buffer" that can grow fast 35// this is a "buffer" that can grow fast
36// and is still somewhat space-efficient. 36// and is still somewhat space-efficient.
… …
56 chunk *first, *last; 56 chunk *first, *last;
57 57
58 void reserve (int size); 58 void reserve (int size);
59 void init (int initial); // allocate sinitial chunk 59 void init (int initial); // allocate sinitial chunk
60 void free (chunk *&chain); // free chain of chunks 60 void free (chunk *&chain); // free chain of chunks
61 char *_linearise (); 61 char *_linearise (int extra = 0);
62 void finalise (); 62 void finalise ();
63 63
64public: 64public:
65 65
66 // initial - the size of the initial chunk to be allocated 66 // initial - the size of the initial chunk to be allocated
… …
90 return first->next ? _linearise () : first->data; 90 return first->next ? _linearise () : first->data;
91 } 91 }
92 92
93 int room () const { return end - ptr; } 93 int room () const { return end - ptr; }
94 94
95 // make sure we have "size" extra room
95 char *force (int size) 96 char *force (int size)
96 { 97 {
97 if (expect_false (ptr + size >= end)) 98 if (expect_false (ptr + size > end))
98 reserve (size); 99 reserve (size);
99 100
101 assume (ptr + size <= end);
102
100 return ptr; 103 return ptr;
101 } 104 }
102 105
106 // used for force + alloc combo
107 void alloc (char *p)
108 {
109 ptr = p;
110 }
111
112 // allocate size bytes and return pointer to them (caller must force())
103 char *falloc (int size) 113 char *falloc (int size)
104 { 114 {
105 char *res = ptr; 115 char *res = ptr;
106 ptr += size; 116 ptr += size;
107 return res; 117 return res;
108 } 118 }
109 119
120 // allocate size bytes and return pointer to them
110 char *alloc (int size) 121 char *alloc (int size)
111 { 122 {
112 force (size); 123 force (size);
113 return falloc (size); 124 return falloc (size);
114 } 125 }
… …
138 149
139 void add (shstr_tmp s) 150 void add (shstr_tmp s)
140 { 151 {
141 add (s.s, s.length ()); 152 add (s.s, s.length ());
142 } 153 }
154
155 // rather inefficient
156 void splice (int offset, int olen, const char *s, int slen);
157 void splice (int offset, int olen) { splice (offset, olen, "", 0); }
143 158
144 //TODO 159 //TODO
145 //void add_destructive (dynbuf &buf); 160 //void add_destructive (dynbuf &buf);
146 161
147 dynbuf &operator << (char c) { add (c); return *this; } 162 dynbuf &operator << (char c) { add (c); return *this; }
… …
175 dynbuf_text &operator << (sint32 i) { add (sint32 (i)); return *this; } 190 dynbuf_text &operator << (sint32 i) { add (sint32 (i)); return *this; }
176 dynbuf_text &operator << (sint64 i) { add (sint64 (i)); return *this; } 191 dynbuf_text &operator << (sint64 i) { add (sint64 (i)); return *this; }
177 dynbuf_text &operator << (uint32 i) { add (sint64 (i)); return *this; } 192 dynbuf_text &operator << (uint32 i) { add (sint64 (i)); return *this; }
178 dynbuf_text &operator << (uint64 i) { add (sint64 (i)); return *this; } 193 dynbuf_text &operator << (uint64 i) { add (sint64 (i)); return *this; }
179 194
180 void printf (const char *format, ...); 195 void printf (const char *format, ...) attribute ((format (printf, 2, 3)));
181 void vprintf (const char *format, va_list ap); 196 void vprintf (const char *format, va_list ap);
182 197
183 void add_abilities (const char *name, uint32 abilities); 198 void add_abilities (const char *name, uint32 abilities);
184 void add_paths (const char *name, uint32 paths); 199 void add_paths (const char *name, uint32 paths);
200
201 // we need to redefine, to keep the API :/
202 using dynbuf::splice;
203 void splice (int offset, int olen, const char *s)
204 {
205 dynbuf::splice (offset, olen, s, strlen (s));
206 }
185 207
186 // returns the string, linearised and with trailing \0 208 // returns the string, linearised and with trailing \0
187 operator char *(); 209 operator char *();
188}; 210};
189 211

Diff Legend

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