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.8 by root, Sat Sep 9 21:48:28 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.8 2006/09/09 21:48:28 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;
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 } 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 }
252} 261}
253 262
254/* convert materialname to materialtype_t */ 263/* convert materialname to materialtype_t */
255 264
265materialtype_t *
256materialtype_t *name_to_material(const char *name) 266name_to_material (const char *name)
257{ 267{
258 materialtype_t *mt, *nmt; 268 materialtype_t *mt, *nmt;
259 269
260 mt = NULL; 270 mt = NULL;
261 for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt=nmt->next) { 271 for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
272 {
262 if (strcmp(name, nmt->name) == 0) { 273 if (strcmp (name, nmt->name) == 0)
274 {
263 mt = nmt; 275 mt = nmt;
264 break; 276 break;
265 } 277 }
266 } 278 }
267 return mt; 279 return mt;
268} 280}
269 281
270/* when doing transmutation of objects, we have to recheck the resistances, 282/* when doing transmutation of objects, we have to recheck the resistances,
271 * as some that did not apply previously, may apply now. 283 * as some that did not apply previously, may apply now.
272 */ 284 */
273 285
286void
274void transmute_materialname(object *op, const object *change) 287transmute_materialname (object *op, const object *change)
275{ 288{
276 materialtype_t *mt; 289 materialtype_t *mt;
277 int j; 290 int j;
278 291
279 if (op->materialname == NULL) 292 if (op->materialname == NULL)
280 return; 293 return;
281 294
282 if (change->materialname != NULL && 295 if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
283 strcmp(op->materialname, change->materialname))
284 return; 296 return;
285 297
286 if (!IS_ARMOR(op)) 298 if (!IS_ARMOR (op))
287 return; 299 return;
288 300
289 mt = name_to_material(op->materialname); 301 mt = name_to_material (op->materialname);
290 if (!mt) { 302 if (!mt)
303 {
291 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);
292 return; 305 return;
293 } 306 }
294 307
295 for (j=0; j < NROFATTACKS; j++) 308 for (j = 0; j < NROFATTACKS; j++)
296 if (op->resist[j] == 0 && change->resist[j] != 0) { 309 if (op->resist[j] == 0 && change->resist[j] != 0)
310 {
297 op->resist[j] += mt->mod[j]; 311 op->resist[j] += mt->mod[j];
298 if (op->resist[j] > 100) 312 if (op->resist[j] > 100)
299 op->resist[j] = 100; 313 op->resist[j] = 100;
300 if (op->resist[j] < -100) 314 if (op->resist[j] < -100)
301 op->resist[j] = -100; 315 op->resist[j] = -100;
302 } 316 }
303} 317}
304 318
305/* set the materialname and type for an item */ 319/* set the materialname and type for an item */
320void
306void set_materialname(object *op, int difficulty, materialtype_t *nmt) 321set_materialname (object *op, int difficulty, materialtype_t *nmt)
307{ 322{
308 materialtype_t *mt, *lmt; 323 materialtype_t *mt, *lmt;
324
309#ifdef NEW_MATERIAL_CODE 325#ifdef NEW_MATERIAL_CODE
310 int j; 326 int j;
311#endif 327#endif
312 328
313 if (op->materialname != NULL) 329 if (op->materialname != NULL)
314 return; 330 return;
315 331
316 332
317 333
318 if (nmt == NULL) { 334 if (nmt == NULL)
335 {
319 lmt = NULL; 336 lmt = NULL;
320#ifndef NEW_MATERIAL_CODE 337#ifndef NEW_MATERIAL_CODE
321 for (mt = materialt; mt != NULL && mt->next != NULL; mt=mt->next) { 338 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
339 {
322 if (op->material & mt->material) { 340 if (op->material & mt->material)
341 {
323 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)))
324 break; 355 break;
325 } 356 }
326 } 357 }
358#endif
359 }
360 else
361 {
362 lmt = nmt;
363 }
327 364
365 if (lmt != NULL)
366 {
367#ifndef NEW_MATERIAL_CODE
368 op->materialname = lmt->name;
369 return;
328#else 370#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 371
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)) { 372 if (op->stats.dam && IS_WEAPON (op))
373 {
350 op->stats.dam += lmt->damage; 374 op->stats.dam += lmt->damage;
351 if (op->stats.dam < 1) 375 if (op->stats.dam < 1)
352 op->stats.dam = 1; 376 op->stats.dam = 1;
353 } 377 }
354 if (op->stats.sp && op->type == BOW) 378 if (op->stats.sp && op->type == BOW)
355 op->stats.sp += lmt->sp; 379 op->stats.sp += lmt->sp;
356 if (op->stats.wc && IS_WEAPON(op)) 380 if (op->stats.wc && IS_WEAPON (op))
357 op->stats.wc += lmt->wc; 381 op->stats.wc += lmt->wc;
358 if (IS_ARMOR(op)) { 382 if (IS_ARMOR (op))
383 {
359 if (op->stats.ac) 384 if (op->stats.ac)
360 op->stats.ac += lmt->ac; 385 op->stats.ac += lmt->ac;
361 for (j=0; j < NROFATTACKS; j++) 386 for (j = 0; j < NROFATTACKS; j++)
362 if (op->resist[j] != 0) { 387 if (op->resist[j] != 0)
388 {
363 op->resist[j] += lmt->mod[j]; 389 op->resist[j] += lmt->mod[j];
364 if (op->resist[j] > 100) 390 if (op->resist[j] > 100)
365 op->resist[j] = 100; 391 op->resist[j] = 100;
366 if (op->resist[j] < -100) 392 if (op->resist[j] < -100)
367 op->resist[j] = -100; 393 op->resist[j] = -100;
368 } 394 }
369 } 395 }
370 op->materialname = add_string(lmt->name); 396 op->materialname = add_string (lmt->name);
371 /* dont make it unstackable if it doesn't need to be */ 397 /* dont make it unstackable if it doesn't need to be */
372 if (IS_WEAPON(op) || IS_ARMOR(op)) { 398 if (IS_WEAPON (op) || IS_ARMOR (op))
399 {
373 op->weight = (op->weight * lmt->weight)/100; 400 op->weight = (op->weight * lmt->weight) / 100;
374 op->value = (op->value * lmt->value)/100; 401 op->value = (op->value * lmt->value) / 100;
375 } 402 }
376#endif 403#endif
377 } 404 }
378} 405}
379 406
380/* 407/*
381 * Strip out the media tags from a String. 408 * Strip out the media tags from a String.
382 * Warning the input string will contain the result string 409 * Warning the input string will contain the result string
383 */ 410 */
411void
384void strip_media_tag(char *message){ 412strip_media_tag (char *message)
413{
385 int in_tag=0; 414 int in_tag = 0;
386 char* dest; 415 char *dest;
387 char* src; 416 char *src;
417
388 src=dest=message; 418 src = dest = message;
389 while (*src!='\0'){ 419 while (*src != '\0')
420 {
390 if (*src=='['){ 421 if (*src == '[')
422 {
391 in_tag=1; 423 in_tag = 1;
424 }
392 } else if (in_tag && (*src==']')) 425 else if (in_tag && (*src == ']'))
393 in_tag=0; 426 in_tag = 0;
394 else if (!in_tag){ 427 else if (!in_tag)
428 {
395 *dest=*src; 429 *dest = *src;
396 dest++; 430 dest++;
397 } 431 }
398 src++; 432 src++;
399 } 433 }
400 *dest='\0'; 434 *dest = '\0';
401} 435}
402 436
437const char *
403const char* strrstr(const char* haystack, const char* needle){ 438strrstr (const char *haystack, const char *needle)
439{
404 const char* lastneedle; 440 const char *lastneedle;
441
405 lastneedle=NULL; 442 lastneedle = NULL;
406 while((haystack=strstr(haystack,needle))!=NULL){ 443 while ((haystack = strstr (haystack, needle)) != NULL)
444 {
407 lastneedle=haystack; 445 lastneedle = haystack;
408 haystack++; 446 haystack++;
409 } 447 }
410 return lastneedle; 448 return lastneedle;
411 449
412} 450}
451
413#define EOL_SIZE (sizeof("\n")-1) 452#define EOL_SIZE (sizeof("\n")-1)
453void
414void strip_endline(char* buf){ 454strip_endline (char *buf)
455{
415 if (strlen(buf)<sizeof("\n")){ 456 if (strlen (buf) < sizeof ("\n"))
457 {
416 return; 458 return;
417 } 459 }
418 if (!strcmp(buf+strlen(buf)-EOL_SIZE,"\n")) 460 if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
419 buf[strlen(buf)-EOL_SIZE]='\0'; 461 buf[strlen (buf) - EOL_SIZE] = '\0';
420} 462}
421 463
422/** 464/**
423 * 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
424 * string is put into result; at most resultsize characters (including the 466 * string is put into result; at most resultsize characters (including the
425 * terminating null character) will be written to result. 467 * terminating null character) will be written to result.
426 */ 468 */
469void
427void 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)
428{ 471{
429 size_t resultlen; 472 size_t resultlen;
430 size_t keylen; 473 size_t keylen;
431 474
432 /* special case to prevent infinite loop if key==replacement=="" */ 475 /* special case to prevent infinite loop if key==replacement=="" */
433 if(strcmp(key, replacement) == 0) 476 if (strcmp (key, replacement) == 0)
434 { 477 {
435 snprintf(result, resultsize, "%s", src); 478 snprintf (result, resultsize, "%s", src);
436 return; 479 return;
437 } 480 }
438 481
439 keylen = strlen(key); 482 keylen = strlen (key);
440 483
441 resultlen = 0; 484 resultlen = 0;
442 while(*src != '\0' && resultlen+1 < resultsize) 485 while (*src != '\0' && resultlen + 1 < resultsize)
443 { 486 {
444 if(strncmp(src, key, keylen) == 0) 487 if (strncmp (src, key, keylen) == 0)
445 { 488 {
446 snprintf(result+resultlen, resultsize-resultlen, "%s", replacement); 489 snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
447 resultlen += strlen(result+resultlen); 490 resultlen += strlen (result + resultlen);
448 src += keylen; 491 src += keylen;
449 } 492 }
450 else 493 else
451 {
452 result[resultlen++] = *src++;
453 }
454 } 494 {
495 result[resultlen++] = *src++;
496 }
497 }
455 result[resultlen] = '\0'; 498 result[resultlen] = '\0';
456} 499}
457 500
458/** 501/**
459 * 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.
460 * 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
461 * 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.
462 * This function will also strip all trailing non alphanumeric characters. 505 * This function will also strip all trailing non alphanumeric characters.
463 * It does not insert an oxford comma. 506 * It does not insert an oxford comma.
464 */ 507 */
465 508
509void
466void make_list_like(char *input) { 510make_list_like (char *input)
511{
467 char *p, tmp[MAX_BUF]; 512 char *p, tmp[MAX_BUF];
468 int i; 513 int i;
514
469 if (!input || strlen(input) > MAX_BUF-5) return; 515 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; 516 return;
488} 517 /* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
489 518
490void * 519 strncpy (tmp, input, MAX_BUF - 5);
491zero_initialised::operator new (size_t s) 520 /*trim all trailing commas, spaces etc. */
492{ 521 for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
493 //return calloc (1, s); 522 tmp[i] = '\0';
494 return g_slice_alloc0 (s);
495}
496 523
497void * 524 strcat (tmp, ".");
498zero_initialised::operator new [] (size_t s)
499{
500 //return calloc (1, s);
501 return g_slice_alloc0 (s);
502}
503 525
504void 526 p = strrchr (tmp, ',');
505zero_initialised::operator delete (void *p, size_t s) 527 if (p)
506{ 528 {
507 //free (p); return; 529 *p = '\0';
508 g_slice_free1 (s, p); 530 strcpy (input, tmp);
509} 531 p++;
532 strcat (input, " and");
533 strcat (input, p);
534 }
535 else
536 strcpy (input, tmp);
510 537
511void 538 return;
512zero_initialised::operator delete [] (void *p, size_t s)
513{
514 //free (p); return;
515 g_slice_free1 (s, p);
516} 539}
517 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{
562 void *p = g_slice_alloc (s);
563
564 if (!p)
565 throw std::bad_alloc ();
566
567 return p;
568}
569
570void assign (char *dst, const char *src, int maxlen)
571{
572 if (!src)
573 src = "";
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