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

Diff Legend

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