mirror of
https://github.com/git/git.git
synced 2024-11-18 22:14:34 +01:00
8e0f70033b
This change removes all obvious useless if-before-free tests.
E.g., it replaces code like this:
if (some_expression)
free (some_expression);
with the now-equivalent:
free (some_expression);
It is equivalent not just because POSIX has required free(NULL)
to work for a long time, but simply because it has worked for
so long that no reasonable porting target fails the test.
Here's some evidence from nearly 1.5 years ago:
http://www.winehq.org/pipermail/wine-patches/2006-October/031544.html
FYI, the change below was prepared by running the following:
git ls-files -z | xargs -0 \
perl -0x3b -pi -e \
's/\bif\s*\(\s*(\S+?)(?:\s*!=\s*NULL)?\s*\)\s+(free\s*\(\s*\1\s*\))/$2/s'
Note however, that it doesn't handle brace-enclosed blocks like
"if (x) { free (x); }". But that's ok, since there were none like
that in git sources.
Beware: if you do use the above snippet, note that it can
produce syntactically invalid C code. That happens when the
affected "if"-statement has a matching "else".
E.g., it would transform this
if (x)
free (x);
else
foo ();
into this:
free (x);
else
foo ();
There were none of those here, either.
If you're interested in automating detection of the useless
tests, you might like the useless-if-before-free script in gnulib:
[it *does* detect brace-enclosed free statements, and has a --name=S
option to make it detect free-like functions with different names]
http://git.sv.gnu.org/gitweb/?p=gnulib.git;a=blob;f=build-aux/useless-if-before-free
Addendum:
Remove one more (in imap-send.c), spotted by Jean-Luc Herren <jlh@gmx.ch>.
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
104 lines
2.1 KiB
C
104 lines
2.1 KiB
C
/*
|
|
* Copyright 2006 Jon Loeliger
|
|
*/
|
|
|
|
#include "git-compat-util.h"
|
|
#include "interpolate.h"
|
|
|
|
|
|
void interp_set_entry(struct interp *table, int slot, const char *value)
|
|
{
|
|
char *oldval = table[slot].value;
|
|
char *newval = NULL;
|
|
|
|
free(oldval);
|
|
|
|
if (value)
|
|
newval = xstrdup(value);
|
|
|
|
table[slot].value = newval;
|
|
}
|
|
|
|
|
|
void interp_clear_table(struct interp *table, int ninterps)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ninterps; i++) {
|
|
interp_set_entry(table, i, NULL);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Convert a NUL-terminated string in buffer orig
|
|
* into the supplied buffer, result, whose length is reslen,
|
|
* performing substitutions on %-named sub-strings from
|
|
* the table, interps, with ninterps entries.
|
|
*
|
|
* Example interps:
|
|
* {
|
|
* { "%H", "example.org"},
|
|
* { "%port", "123"},
|
|
* { "%%", "%"},
|
|
* }
|
|
*
|
|
* Returns the length of the substituted string (not including the final \0).
|
|
* Like with snprintf, if the result is >= reslen, then it overflowed.
|
|
*/
|
|
|
|
unsigned long interpolate(char *result, unsigned long reslen,
|
|
const char *orig,
|
|
const struct interp *interps, int ninterps)
|
|
{
|
|
const char *src = orig;
|
|
char *dest = result;
|
|
unsigned long newlen = 0;
|
|
const char *name, *value;
|
|
unsigned long namelen, valuelen;
|
|
int i;
|
|
char c;
|
|
|
|
while ((c = *src)) {
|
|
if (c == '%') {
|
|
/* Try to match an interpolation string. */
|
|
for (i = 0; i < ninterps; i++) {
|
|
name = interps[i].name;
|
|
namelen = strlen(name);
|
|
if (strncmp(src, name, namelen) == 0)
|
|
break;
|
|
}
|
|
|
|
/* Check for valid interpolation. */
|
|
if (i < ninterps) {
|
|
value = interps[i].value;
|
|
if (!value) {
|
|
src += namelen;
|
|
continue;
|
|
}
|
|
|
|
valuelen = strlen(value);
|
|
if (newlen + valuelen < reslen) {
|
|
/* Substitute. */
|
|
memcpy(dest, value, valuelen);
|
|
dest += valuelen;
|
|
}
|
|
newlen += valuelen;
|
|
src += namelen;
|
|
continue;
|
|
}
|
|
}
|
|
/* Straight copy one non-interpolation character. */
|
|
if (newlen + 1 < reslen)
|
|
*dest++ = *src;
|
|
src++;
|
|
newlen++;
|
|
}
|
|
|
|
/* XXX: the previous loop always keep room for the ending NUL,
|
|
we just need to check if there was room for a NUL in the first place */
|
|
if (reslen > 0)
|
|
*dest = '\0';
|
|
return newlen;
|
|
}
|