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.1 by elmex, Sun Aug 13 17:16:01 2006 UTC vs.
Revision 1.25 by root, Sun Dec 17 23:10:34 2006 UTC

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

Diff Legend

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