ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/utils.C
(Generate patch)

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.4 by root, Mon Sep 4 11:07:59 2006 UTC vs.
Revision 1.23 by root, Sat Dec 16 03:08:25 2006 UTC

1/*
2 * static char *rcsid_utils_c =
3 * "$Id: utils.C,v 1.4 2006/09/04 11:07:59 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 22*/
28 23
29/* 24/*
30 * General convenience functions for crossfire. 25 * General convenience functions for crossfire.
31 */ 26 */
32 27
33#include <global.h> 28#include <global.h>
34#include <funcpoint.h> 29#include <funcpoint.h>
35#include <material.h> 30#include <material.h>
36 31
32#include <sys/time.h>
33#include <time.h>
37#include <glib.h> 34#include <glib.h>
38 35
39/* 36/*
40 * The random functions here take luck into account when rolling random 37 * The random functions here take luck into account when rolling random
41 * dice or numbers. This function has less of an impact the larger the 38 * dice or numbers. This function has less of an impact the larger the
… …
50 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases. 47 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
51 * Generally, op should be the player/caster/hitter requesting the roll, 48 * Generally, op should be the player/caster/hitter requesting the roll,
52 * not the recipient (ie, the poor slob getting hit). [garbled 20010916] 49 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
53 */ 50 */
54 51
52int
55int random_roll(int min, int max, const object *op, int goodbad) { 53random_roll (int min, int max, const object *op, int goodbad)
54{
56 int omin, diff, luck, base, ran; 55 int omin, diff, luck, base, ran;
57 56
58 omin = min; 57 omin = min;
59 diff = max - min + 1; 58 diff = max - min + 1;
60 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 59 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
61 60
62 if (max < 1 || diff < 1) { 61 if (max < 1 || diff < 1)
62 {
63 LOG(llevError, "Calling random_roll with min=%d max=%d\n", min, max); 63 LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max);
64 return(min); /* avoids a float exception */ 64 return (min); /* avoids a float exception */
65 } 65 }
66 66
67 ran = RANDOM(); 67 ran = RANDOM ();
68 68
69 if (op->type != PLAYER) 69 if (op->type != PLAYER)
70 return((ran%diff)+min); 70 return ((ran % diff) + min);
71 71
72 luck = op->stats.luck; 72 luck = op->stats.luck;
73 if (RANDOM()%base < MIN(10, abs(luck))) { 73 if (RANDOM () % base < MIN (10, abs (luck)))
74 {
74 /* we have a winner */ 75 /* we have a winner */
75 ((luck > 0) ? (luck = 1) : (luck = -1)); 76 ((luck > 0) ? (luck = 1) : (luck = -1));
76 diff -= luck; 77 diff -= luck;
77 if (diff < 1) 78 if (diff < 1)
78 return(omin); /*check again*/ 79 return (omin); /*check again */
79 ((goodbad) ? (min += luck) : (diff)); 80 ((goodbad) ? (min += luck) : (diff));
80 81
81 return(MAX(omin, MIN(max, (ran%diff)+min))); 82 return (MAX (omin, MIN (max, (ran % diff) + min)));
82 } 83 }
83 return((ran%diff)+min); 84 return ((ran % diff) + min);
84} 85}
85 86
86/* 87/*
87 * This is a 64 bit version of random_roll above. This is needed 88 * This is a 64 bit version of random_roll above. This is needed
88 * for exp loss calculations for players changing religions. 89 * for exp loss calculations for players changing religions.
89 */ 90 */
90 91
92sint64
91sint64 random_roll64(sint64 min, sint64 max, const object *op, int goodbad) { 93random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
94{
92 sint64 omin, diff, luck, ran; 95 sint64 omin, diff, luck, ran;
93 int base; 96 int base;
94 97
95 omin = min; 98 omin = min;
96 diff = max - min + 1; 99 diff = max - min + 1;
97 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 100 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
98 101
99 if (max < 1 || diff < 1) { 102 if (max < 1 || diff < 1)
100#ifndef WIN32 103 {
101 LOG(llevError, "Calling random_roll with min=%lld max=%lld\n", min, max);
102#else
103 LOG(llevError, "Calling random_roll with min=%I64d max=%I64d\n", min, max); 104 LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
104#endif
105 return(min); /* avoids a float exception */ 105 return (min); /* avoids a float exception */
106 } 106 }
107 107
108 /* Don't know of a portable call to get 64 bit random values. 108 /* Don't know of a portable call to get 64 bit random values.
109 * So make a call to get two 32 bit random numbers, and just to 109 * So make a call to get two 32 bit random numbers, and just to
110 * a little byteshifting. Do make sure the first one is only 110 * a little byteshifting. Do make sure the first one is only
111 * 32 bit, so we don't get skewed results 111 * 32 bit, so we don't get skewed results
112 */ 112 */
113 ran = (RANDOM() & 0xffffffff) | ((sint64)RANDOM() << 32); 113 ran = (RANDOM () & 0xffffffff) | ((sint64) RANDOM () << 32);
114 114
115 if (op->type != PLAYER) 115 if (op->type != PLAYER)
116 return((ran%diff)+min); 116 return ((ran % diff) + min);
117 117
118 luck = op->stats.luck; 118 luck = op->stats.luck;
119 if (RANDOM()%base < MIN(10, abs(luck))) { 119 if (RANDOM () % base < MIN (10, abs (luck)))
120 {
120 /* we have a winner */ 121 /* we have a winner */
121 ((luck > 0) ? (luck = 1) : (luck = -1)); 122 ((luck > 0) ? (luck = 1) : (luck = -1));
122 diff -= luck; 123 diff -= luck;
123 if (diff < 1) 124 if (diff < 1)
124 return(omin); /*check again*/ 125 return (omin); /*check again */
125 ((goodbad) ? (min += luck) : (diff)); 126 ((goodbad) ? (min += luck) : (diff));
126 127
127 return(MAX(omin, MIN(max, (ran%diff)+min))); 128 return (MAX (omin, MIN (max, (ran % diff) + min)));
128 } 129 }
129 return((ran%diff)+min); 130 return ((ran % diff) + min);
130} 131}
131 132
132/* 133/*
133 * Roll a number of dice (2d3, 4d6). Uses op to determine luck, 134 * Roll a number of dice (2d3, 4d6). Uses op to determine luck,
134 * If goodbad is non-zero, luck increases the roll, if zero, it decreases. 135 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
135 * Generally, op should be the player/caster/hitter requesting the roll, 136 * Generally, op should be the player/caster/hitter requesting the roll,
136 * not the recipient (ie, the poor slob getting hit). 137 * not the recipient (ie, the poor slob getting hit).
137 * The args are num D size (ie 4d6) [garbled 20010916] 138 * The args are num D size (ie 4d6) [garbled 20010916]
138 */ 139 */
139 140
141int
140int die_roll(int num, int size, const object *op, int goodbad) { 142die_roll (int num, int size, const object *op, int goodbad)
143{
141 int min, diff, luck, total, i, gotlucky, base, ran; 144 int min, diff, luck, total, i, gotlucky, base, ran;
142 145
143 diff = size; 146 diff = size;
144 min = 1; 147 min = 1;
145 luck = total = gotlucky = 0; 148 luck = total = gotlucky = 0;
146 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 149 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
147 if (size < 2 || diff < 1) { 150 if (size < 2 || diff < 1)
151 {
148 LOG(llevError, "Calling die_roll with num=%d size=%d\n", num, size); 152 LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
149 return(num); /* avoids a float exception */ 153 return (num); /* avoids a float exception */
150 } 154 }
151 155
152 if (op->type == PLAYER) 156 if (op->type == PLAYER)
153 luck = op->stats.luck; 157 luck = op->stats.luck;
154 158
155 for (i = 0; i < num; i++) { 159 for (i = 0; i < num; i++)
160 {
156 if (RANDOM()%base < MIN(10, abs(luck)) && !gotlucky) { 161 if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky)
162 {
157 /* we have a winner */ 163 /* we have a winner */
158 gotlucky++; 164 gotlucky++;
159 ((luck > 0) ? (luck = 1) : (luck = -1)); 165 ((luck > 0) ? (luck = 1) : (luck = -1));
160 diff -= luck; 166 diff -= luck;
161 if (diff < 1) 167 if (diff < 1)
162 return(num); /*check again*/ 168 return (num); /*check again */
163 ((goodbad) ? (min += luck) : (diff)); 169 ((goodbad) ? (min += luck) : (diff));
164 ran = RANDOM(); 170 ran = RANDOM ();
165 total += MAX(1, MIN(size, (ran%diff)+min)); 171 total += MAX (1, MIN (size, (ran % diff) + min));
172 }
166 } else { 173 else
174 {
167 total += RANDOM()%size+1; 175 total += RANDOM () % size + 1;
168 } 176 }
169 } 177 }
170 return(total); 178 return (total);
171} 179}
172 180
173/* 181/*
174 * Another convenience function. Returns a number between min and max. 182 * Another convenience function. Returns a number between min and max.
175 * It is suggested one use these functions rather than RANDOM()%, as it 183 * It is suggested one use these functions rather than RANDOM()%, as it
176 * would appear that a number of off-by-one-errors exist due to improper 184 * would appear that a number of off-by-one-errors exist due to improper
177 * use of %. This should also prevent SIGFPE. 185 * use of %. This should also prevent SIGFPE.
178 */ 186 */
179 187
188int
180int rndm(int min, int max) 189rndm (int min, int max)
181{ 190{
182 int diff; 191 int diff;
183 192
184 diff = max - min + 1; 193 diff = max - min + 1;
185 if (max < 1 || diff < 1) 194 if (max < 1 || diff < 1)
186 return(min); 195 return (min);
187 196
188 return(RANDOM()%diff+min); 197 return (RANDOM () % diff + min);
189} 198}
190 199
191/* decay and destroy persihable items in a map */ 200/* decay and destroy persihable items in a map */
192 201
202void
193void decay_objects(mapstruct *m) 203decay_objects (maptile *m)
194{ 204{
195 int x, y, destroy; 205 int x, y, destroy;
196 object *op, *otmp; 206 object *op, *otmp;
197 207
198 if (m->unique) 208 if (m->unique)
199 return; 209 return;
200 210
201 for (x=0; x < MAP_WIDTH(m); x++) 211 for (x = 0; x < MAP_WIDTH (m); x++)
202 for (y=0; y < MAP_HEIGHT(m); y++) 212 for (y = 0; y < MAP_HEIGHT (m); y++)
203 for (op = get_map_ob(m, x, y); op; op = otmp) { 213 for (op = get_map_ob (m, x, y); op; op = otmp)
214 {
215 destroy = 0;
216 otmp = op->above;
217 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
218 break;
219 if (QUERY_FLAG (op, FLAG_IS_FLOOR) ||
220 QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) ||
221 QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL) ||
222 QUERY_FLAG (op, FLAG_UNIQUE) || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR) || QUERY_FLAG (op, FLAG_UNPAID) || IS_LIVE (op))
223 continue;
224 /* otherwise, we decay and destroy */
225 if (IS_WEAPON (op))
226 {
227 op->stats.dam--;
228 if (op->stats.dam < 0)
204 destroy = 0; 229 destroy = 1;
205 otmp = op->above;
206 if (QUERY_FLAG(op,FLAG_IS_FLOOR) && QUERY_FLAG(op, FLAG_UNIQUE))
207 break;
208 if (QUERY_FLAG(op, FLAG_IS_FLOOR) ||
209 QUERY_FLAG(op, FLAG_OBJ_ORIGINAL) ||
210 QUERY_FLAG(op, FLAG_OBJ_SAVE_ON_OVL) ||
211 QUERY_FLAG(op, FLAG_UNIQUE) ||
212 QUERY_FLAG(op, FLAG_OVERLAY_FLOOR) ||
213 QUERY_FLAG(op, FLAG_UNPAID) || IS_LIVE(op))
214 continue;
215 /* otherwise, we decay and destroy */
216 if (IS_WEAPON(op)) {
217 op->stats.dam--;
218 if (op->stats.dam < 0)
219 destroy = 1;
220 } else if (IS_ARMOR(op)) {
221 op->stats.ac--;
222 if (op->stats.ac < 0)
223 destroy = 1;
224 } else if (op->type == FOOD) {
225 op->stats.food -= rndm(5,20);
226 if (op->stats.food < 0)
227 destroy = 1;
228 } else {
229 if (op->material & M_PAPER || op->material & M_LEATHER ||
230 op->material & M_WOOD || op->material & M_ORGANIC ||
231 op->material & M_CLOTH || op->material & M_LIQUID)
232 destroy = 1;
233 if (op->material & M_IRON && rndm(1,5) == 1)
234 destroy = 1;
235 if (op->material & M_GLASS && rndm(1,2) == 1)
236 destroy = 1;
237 if ((op->material & M_STONE || op->material & M_ADAMANT) &&
238 rndm(1,10) == 1)
239 destroy = 1;
240 if ((op->material & M_SOFT_METAL || op->material & M_BONE) &&
241 rndm(1,3) == 1)
242 destroy = 1;
243 if (op->material & M_ICE && MAP_TEMP(m) > 32)
244 destroy = 1;
245 }
246 /* adjust overall chance below */
247 if (destroy && rndm(0, 1)) {
248 remove_ob(op);
249 free_object(op);
250 }
251 } 230 }
231 else if (IS_ARMOR (op))
232 {
233 op->stats.ac--;
234 if (op->stats.ac < 0)
235 destroy = 1;
236 }
237 else if (op->type == FOOD)
238 {
239 op->stats.food -= rndm (5, 20);
240 if (op->stats.food < 0)
241 destroy = 1;
242 }
243 else
244 {
245 if (op->material & M_PAPER || op->material & M_LEATHER ||
246 op->material & M_WOOD || op->material & M_ORGANIC || op->material & M_CLOTH || op->material & M_LIQUID)
247 destroy = 1;
248 if (op->material & M_IRON && rndm (1, 5) == 1)
249 destroy = 1;
250 if (op->material & M_GLASS && rndm (1, 2) == 1)
251 destroy = 1;
252 if ((op->material & M_STONE || op->material & M_ADAMANT) && rndm (1, 10) == 1)
253 destroy = 1;
254 if ((op->material & M_SOFT_METAL || op->material & M_BONE) && rndm (1, 3) == 1)
255 destroy = 1;
256 if (op->material & M_ICE && MAP_TEMP (m) > 32)
257 destroy = 1;
258 }
259 /* adjust overall chance below */
260 if (destroy && rndm (0, 1))
261 op->destroy ();
262 }
252} 263}
253 264
254/* convert materialname to materialtype_t */ 265/* convert materialname to materialtype_t */
255 266
267materialtype_t *
256materialtype_t *name_to_material(const char *name) 268name_to_material (const char *name)
257{ 269{
258 materialtype_t *mt, *nmt; 270 materialtype_t *mt, *nmt;
259 271
260 mt = NULL; 272 mt = NULL;
261 for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt=nmt->next) { 273 for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
274 {
262 if (strcmp(name, nmt->name) == 0) { 275 if (strcmp (name, nmt->name) == 0)
276 {
263 mt = nmt; 277 mt = nmt;
264 break; 278 break;
265 } 279 }
266 } 280 }
267 return mt; 281 return mt;
268} 282}
269 283
270/* when doing transmutation of objects, we have to recheck the resistances, 284/* when doing transmutation of objects, we have to recheck the resistances,
271 * as some that did not apply previously, may apply now. 285 * as some that did not apply previously, may apply now.
272 */ 286 */
273 287
288void
274void transmute_materialname(object *op, const object *change) 289transmute_materialname (object *op, const object *change)
275{ 290{
276 materialtype_t *mt; 291 materialtype_t *mt;
277 int j; 292 int j;
278 293
279 if (op->materialname == NULL) 294 if (op->materialname == NULL)
280 return; 295 return;
281 296
282 if (change->materialname != NULL && 297 if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
283 strcmp(op->materialname, change->materialname))
284 return; 298 return;
285 299
286 if (!IS_ARMOR(op)) 300 if (!IS_ARMOR (op))
287 return; 301 return;
288 302
289 mt = name_to_material(op->materialname); 303 mt = name_to_material (op->materialname);
290 if (!mt) { 304 if (!mt)
305 {
291 LOG(llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname); 306 LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);
292 return; 307 return;
293 } 308 }
294 309
295 for (j=0; j < NROFATTACKS; j++) 310 for (j = 0; j < NROFATTACKS; j++)
296 if (op->resist[j] == 0 && change->resist[j] != 0) { 311 if (op->resist[j] == 0 && change->resist[j] != 0)
312 {
297 op->resist[j] += mt->mod[j]; 313 op->resist[j] += mt->mod[j];
298 if (op->resist[j] > 100) 314 if (op->resist[j] > 100)
299 op->resist[j] = 100; 315 op->resist[j] = 100;
300 if (op->resist[j] < -100) 316 if (op->resist[j] < -100)
301 op->resist[j] = -100; 317 op->resist[j] = -100;
302 } 318 }
303} 319}
304 320
305/* set the materialname and type for an item */ 321/* set the materialname and type for an item */
322void
306void set_materialname(object *op, int difficulty, materialtype_t *nmt) 323set_materialname (object *op, int difficulty, materialtype_t *nmt)
307{ 324{
308 materialtype_t *mt, *lmt; 325 materialtype_t *mt, *lmt;
326
327#ifdef NEW_MATERIAL_CODE
309 int j; 328 int j;
329#endif
310 330
311 if (op->materialname != NULL) 331 if (op->materialname != NULL)
312 return; 332 return;
313 333
314 334
315 335
316 if (nmt == NULL) { 336 if (nmt == NULL)
337 {
317 lmt = NULL; 338 lmt = NULL;
318#ifndef NEW_MATERIAL_CODE 339#ifndef NEW_MATERIAL_CODE
319 for (mt = materialt; mt != NULL && mt->next != NULL; mt=mt->next) { 340 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
341 {
320 if (op->material & mt->material) { 342 if (op->material & mt->material)
343 {
321 lmt = mt; 344 lmt = mt;
345 break;
346 }
347 }
348
349#else
350 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
351 {
352 if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
353 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
354 {
355 lmt = mt;
356 if (!(IS_WEAPON (op) || IS_ARMOR (op)))
322 break; 357 break;
323 } 358 }
324 } 359 }
360#endif
361 }
362 else
363 {
364 lmt = nmt;
365 }
325 366
367 if (lmt != NULL)
368 {
369#ifndef NEW_MATERIAL_CODE
370 op->materialname = lmt->name;
371 return;
326#else 372#else
327 for (mt = materialt; mt != NULL && mt->next != NULL; mt=mt->next) {
328 if (op->material & mt->material && rndm(1, 100) <= mt->chance &&
329 difficulty >= mt->difficulty &&
330 (op->magic >= mt->magic || mt->magic == 0)) {
331 lmt = mt;
332 if (!(IS_WEAPON(op) || IS_ARMOR(op)))
333 break;
334 }
335 }
336#endif
337 } else {
338 lmt = nmt;
339 }
340 373
341 if (lmt != NULL) {
342#ifndef NEW_MATERIAL_CODE
343 op->materialname = lmt->name;
344 return;
345#else
346
347 if (op->stats.dam && IS_WEAPON(op)) { 374 if (op->stats.dam && IS_WEAPON (op))
375 {
348 op->stats.dam += lmt->damage; 376 op->stats.dam += lmt->damage;
349 if (op->stats.dam < 1) 377 if (op->stats.dam < 1)
350 op->stats.dam = 1; 378 op->stats.dam = 1;
351 } 379 }
352 if (op->stats.sp && op->type == BOW) 380 if (op->stats.sp && op->type == BOW)
353 op->stats.sp += lmt->sp; 381 op->stats.sp += lmt->sp;
354 if (op->stats.wc && IS_WEAPON(op)) 382 if (op->stats.wc && IS_WEAPON (op))
355 op->stats.wc += lmt->wc; 383 op->stats.wc += lmt->wc;
356 if (IS_ARMOR(op)) { 384 if (IS_ARMOR (op))
385 {
357 if (op->stats.ac) 386 if (op->stats.ac)
358 op->stats.ac += lmt->ac; 387 op->stats.ac += lmt->ac;
359 for (j=0; j < NROFATTACKS; j++) 388 for (j = 0; j < NROFATTACKS; j++)
360 if (op->resist[j] != 0) { 389 if (op->resist[j] != 0)
390 {
361 op->resist[j] += lmt->mod[j]; 391 op->resist[j] += lmt->mod[j];
362 if (op->resist[j] > 100) 392 if (op->resist[j] > 100)
363 op->resist[j] = 100; 393 op->resist[j] = 100;
364 if (op->resist[j] < -100) 394 if (op->resist[j] < -100)
365 op->resist[j] = -100; 395 op->resist[j] = -100;
366 } 396 }
367 } 397 }
368 op->materialname = add_string(lmt->name); 398 op->materialname = add_string (lmt->name);
369 /* dont make it unstackable if it doesn't need to be */ 399 /* dont make it unstackable if it doesn't need to be */
370 if (IS_WEAPON(op) || IS_ARMOR(op)) { 400 if (IS_WEAPON (op) || IS_ARMOR (op))
401 {
371 op->weight = (op->weight * lmt->weight)/100; 402 op->weight = (op->weight * lmt->weight) / 100;
372 op->value = (op->value * lmt->value)/100; 403 op->value = (op->value * lmt->value) / 100;
373 } 404 }
374#endif 405#endif
375 } 406 }
376} 407}
377 408
378/* 409/*
379 * Strip out the media tags from a String. 410 * Strip out the media tags from a String.
380 * Warning the input string will contain the result string 411 * Warning the input string will contain the result string
381 */ 412 */
413void
382void strip_media_tag(char *message){ 414strip_media_tag (char *message)
415{
383 int in_tag=0; 416 int in_tag = 0;
384 char* dest; 417 char *dest;
385 char* src; 418 char *src;
419
386 src=dest=message; 420 src = dest = message;
387 while (*src!='\0'){ 421 while (*src != '\0')
422 {
388 if (*src=='['){ 423 if (*src == '[')
424 {
389 in_tag=1; 425 in_tag = 1;
426 }
390 } else if (in_tag && (*src==']')) 427 else if (in_tag && (*src == ']'))
391 in_tag=0; 428 in_tag = 0;
392 else if (!in_tag){ 429 else if (!in_tag)
430 {
393 *dest=*src; 431 *dest = *src;
394 dest++; 432 dest++;
395 } 433 }
396 src++; 434 src++;
397 } 435 }
398 *dest='\0'; 436 *dest = '\0';
399} 437}
400 438
439const char *
401const char* strrstr(const char* haystack, const char* needle){ 440strrstr (const char *haystack, const char *needle)
441{
402 const char* lastneedle; 442 const char *lastneedle;
443
403 lastneedle=NULL; 444 lastneedle = NULL;
404 while((haystack=strstr(haystack,needle))!=NULL){ 445 while ((haystack = strstr (haystack, needle)) != NULL)
446 {
405 lastneedle=haystack; 447 lastneedle = haystack;
406 haystack++; 448 haystack++;
407 } 449 }
408 return lastneedle; 450 return lastneedle;
409 451
410} 452}
453
411#define EOL_SIZE (sizeof("\n")-1) 454#define EOL_SIZE (sizeof("\n")-1)
455void
412void strip_endline(char* buf){ 456strip_endline (char *buf)
457{
413 if (strlen(buf)<sizeof("\n")){ 458 if (strlen (buf) < sizeof ("\n"))
459 {
414 return; 460 return;
415 } 461 }
416 if (!strcmp(buf+strlen(buf)-EOL_SIZE,"\n")) 462 if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
417 buf[strlen(buf)-EOL_SIZE]='\0'; 463 buf[strlen (buf) - EOL_SIZE] = '\0';
418} 464}
419 465
420/** 466/**
421 * Replace in string src all occurrences of key by replacement. The resulting 467 * Replace in string src all occurrences of key by replacement. The resulting
422 * string is put into result; at most resultsize characters (including the 468 * string is put into result; at most resultsize characters (including the
423 * terminating null character) will be written to result. 469 * terminating null character) will be written to result.
424 */ 470 */
471void
425void replace(const char *src, const char *key, const char *replacement, char *result, size_t resultsize) 472replace (const char *src, const char *key, const char *replacement, char *result, size_t resultsize)
426{ 473{
427 size_t resultlen; 474 size_t resultlen;
428 size_t keylen; 475 size_t keylen;
429 476
430 /* special case to prevent infinite loop if key==replacement=="" */ 477 /* special case to prevent infinite loop if key==replacement=="" */
431 if(strcmp(key, replacement) == 0) 478 if (strcmp (key, replacement) == 0)
432 { 479 {
433 snprintf(result, resultsize, "%s", src); 480 snprintf (result, resultsize, "%s", src);
434 return; 481 return;
435 } 482 }
436 483
437 keylen = strlen(key); 484 keylen = strlen (key);
438 485
439 resultlen = 0; 486 resultlen = 0;
440 while(*src != '\0' && resultlen+1 < resultsize) 487 while (*src != '\0' && resultlen + 1 < resultsize)
441 { 488 {
442 if(strncmp(src, key, keylen) == 0) 489 if (strncmp (src, key, keylen) == 0)
443 { 490 {
444 snprintf(result+resultlen, resultsize-resultlen, "%s", replacement); 491 snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
445 resultlen += strlen(result+resultlen); 492 resultlen += strlen (result + resultlen);
446 src += keylen; 493 src += keylen;
447 } 494 }
448 else 495 else
449 {
450 result[resultlen++] = *src++;
451 }
452 } 496 {
497 result[resultlen++] = *src++;
498 }
499 }
453 result[resultlen] = '\0'; 500 result[resultlen] = '\0';
454} 501}
455 502
456/** 503/**
457 * Taking a string as an argument, mutate it into a string that looks like a list. 504 * Taking a string as an argument, mutate it into a string that looks like a list.
458 * a 'list' for the purposes here, is a string of items, seperated by commas, except 505 * a 'list' for the purposes here, is a string of items, seperated by commas, except
459 * for the last entry, which has an 'and' before it, and a full stop (period) after it. 506 * for the last entry, which has an 'and' before it, and a full stop (period) after it.
460 * This function will also strip all trailing non alphanumeric characters. 507 * This function will also strip all trailing non alphanumeric characters.
461 * It does not insert an oxford comma. 508 * It does not insert an oxford comma.
462 */ 509 */
463 510
511void
464void make_list_like(char *input) { 512make_list_like (char *input)
513{
465 char *p, tmp[MAX_BUF]; 514 char *p, tmp[MAX_BUF];
466 int i; 515 int i;
516
467 if (!input || strlen(input) > MAX_BUF-5) return; 517 if (!input || strlen (input) > MAX_BUF - 5)
468 /* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
469
470 strncpy(tmp, input, MAX_BUF-5);
471 /*trim all trailing commas, spaces etc.*/
472 for (i=strlen(tmp); !isalnum(tmp[i]) && i >= 0; i--)
473 tmp[i]='\0';
474 strcat(tmp, ".");
475
476 p=strrchr(tmp, ',');
477 if (p) {
478 *p='\0';
479 strcpy(input, tmp);
480 p++;
481 strcat(input, " and");
482 strcat(input, p);
483 }
484 else strcpy(input, tmp);
485 return; 518 return;
486} 519 /* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
487 520
488//TODO: overhead due to specifying size twice 521 strncpy (tmp, input, MAX_BUF - 5);
489void * 522 /*trim all trailing commas, spaces etc. */
490zero_initialised::operator new (size_t s) 523 for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
491{ 524 tmp[i] = '\0';
492 return g_slice_alloc0 (s);
493}
494 525
495void * 526 strcat (tmp, ".");
496zero_initialised::operator new [] (size_t s)
497{
498 return g_slice_alloc0 (s);
499}
500 527
501void 528 p = strrchr (tmp, ',');
502zero_initialised::operator delete (void *p, size_t s) 529 if (p)
503{ 530 {
504 g_slice_free1 (s, p); 531 *p = '\0';
505} 532 strcpy (input, tmp);
533 p++;
534 strcat (input, " and");
535 strcat (input, p);
536 }
537 else
538 strcpy (input, tmp);
506 539
507void 540 return;
508zero_initialised::operator delete [] (void *p, size_t s)
509{
510 g_slice_free1 (s, p);
511} 541}
512 542
543/////////////////////////////////////////////////////////////////////////////
544
545#if 0
546refcounted *refcounted::rc_first;
547
548refcounted::refcounted ()
549{
550 refcnt = 0;
551 rc_next = rc_first;
552 rc_first = this;
553}
554
555refcounted::~refcounted ()
556{
557 assert (!rc_next);
558 assert (!refcnt);
559}
560#endif
561
562void *salloc (int size) throw (std::bad_alloc)
563{
564 void *ptr = g_slice_alloc (size);
565
566 if (!ptr)
567 throw std::bad_alloc ();
568
569 return ptr;
570}
571
572void *salloc (int size, void *src) throw (std::bad_alloc)
573{
574 void *ptr = salloc (size);
575
576 memcpy (ptr, src, size);
577
578 return ptr;
579}
580
581void assign (char *dst, const char *src, int maxlen)
582{
583 if (!src)
584 src = "";
585
586 int len = strlen (src);
587
588 if (len >= maxlen - 1)
589 {
590 if (maxlen <= 4)
591 {
592 memset (dst, '.', maxlen - 1);
593 dst [maxlen - 1] = 0;
594 }
595 else
596 {
597 memcpy (dst, src, maxlen - 4);
598 memcpy (dst + maxlen - 4, "...", 4);
599 }
600 }
601 else
602 memcpy (dst, src, len + 1);
603}
604
605tstamp now ()
606{
607 struct timeval tv;
608
609 gettimeofday (&tv, 0);
610 return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
611}
612

Diff Legend

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