Instead Of: Use:
- t* p = malloc(n) New(id, p, n, t)
- t* p = calloc(n, s) Newz(id, p, n, t)
+ t* p = malloc(n) Newx(id, p, n, t)
+ t* p = calloc(n, s) Newxz(id, p, n, t)
p = realloc(p, n) Renew(p, n, t)
memcpy(dst, src, n) Copy(src, dst, n, t)
memmove(dst, src, n) Move(src, dst, n, t)
- memcpy/*(struct foo *) StructCopy(src, dst, t)
+ memcpy(dst, src, sizeof(t)) StructCopy(src, dst, t)
memset(dst, 0, n * sizeof(t)) Zero(dst, n, t)
memzero(dst, 0) Zero(dst, n, char)
free(p) Safefree(p)
Note also the existence of C<sv_catpvf> and C<sv_vcatpvfn>, combining
concatenation with formatting.
-Sometimes instead of zeroing the allocated heap by using Newz() you
+Sometimes instead of zeroing the allocated heap by using Newxz() you
should consider "poisoning" the data. This means writing a bit
pattern into it that should be illegal as pointers (and floating point
numbers), and also hopefully surprising enough as integers, so that
any code attempting to use the data without forethought will break
sooner rather than later. Poisoning can be done using the Poison()
-macro, which has similar arguments as Zero():
+macros, which have similar arguments as Zero():
- Poison(dst, n, t)
+ PoisonWith(dst, n, t, b) scribble memory with byte b
+ PoisonNew(dst, n, t) equal to PoisonWith(dst, n, t, 0xAB)
+ PoisonFree(dst, n, t) equal to PoisonWith(dst, n, t, 0xEF)
+ Poison(dst, n, t) equal to PoisonFree(dst, n, t)
=head2 Character Class Tests
atof(s) Atof(s)
atol(s) Atol(s)
- strtod(s, *p) Nothing. Just don't use it.
- strtol(s, *p, n) Strtol(s, *p, n)
- strtoul(s, *p, n) Strtoul(s, *p, n)
+ strtod(s, &p) Nothing. Just don't use it.
+ strtol(s, &p, n) Strtol(s, &p, n)
+ strtoul(s, &p, n) Strtoul(s, &p, n)
Notice also the C<grok_bin>, C<grok_hex>, and C<grok_oct> functions in
F<numeric.c> for converting strings representing numbers in the respective