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.3 by root, Sun Sep 3 00:18:40 2006 UTC vs.
Revision 1.22 by root, Tue Dec 12 21:39:56 2006 UTC

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

Diff Legend

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