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.5 by pippijn, Thu Sep 7 09:37:12 2006 UTC vs.
Revision 1.17 by root, Fri Nov 17 19:40:53 2006 UTC

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

Diff Legend

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