unsigned long size, nsize;
struct text_stat stats;
- if ((action == CRLF_BINARY) || (action == CRLF_GUESS && !auto_crlf))
+ if ((action == CRLF_BINARY) || !auto_crlf)
return NULL;
size = *sizep;
unsigned char last;
if ((action == CRLF_BINARY) || (action == CRLF_INPUT) ||
- (action == CRLF_GUESS && auto_crlf <= 0))
+ auto_crlf <= 0)
return NULL;
size = *sizep;
static int count_ident(const char *cp, unsigned long size)
{
/*
- * "$ident: 0000000000000000000000000000000000000000 $" <=> "$ident$"
+ * "$Id: 0000000000000000000000000000000000000000 $" <=> "$Id$"
*/
int cnt = 0;
char ch;
size--;
if (ch != '$')
continue;
- if (size < 6)
+ if (size < 3)
break;
- if (memcmp("ident", cp, 5))
+ if (memcmp("Id", cp, 2))
continue;
- ch = cp[5];
- cp += 6;
- size -= 6;
+ ch = cp[2];
+ cp += 3;
+ size -= 3;
if (ch == '$')
- cnt++; /* $ident$ */
+ cnt++; /* $Id$ */
if (ch != ':')
continue;
/*
- * "$ident: ... "; scan up to the closing dollar sign and discard.
+ * "$Id: ... "; scan up to the closing dollar sign and discard.
*/
while (size) {
ch = *cp++;
for (dst = buf; size; size--) {
char ch = *src++;
*dst++ = ch;
- if ((ch == '$') && (6 <= size) &&
- !memcmp("ident:", src, 6)) {
- unsigned long rem = size - 6;
- const char *cp = src + 6;
+ if ((ch == '$') && (3 <= size) &&
+ !memcmp("Id:", src, 3)) {
+ unsigned long rem = size - 3;
+ const char *cp = src + 3;
do {
ch = *cp++;
if (ch == '$')
} while (rem);
if (!rem)
continue;
- memcpy(dst, "ident$", 6);
- dst += 6;
+ memcpy(dst, "Id$", 3);
+ dst += 3;
size -= (cp - src);
src = cp;
}
for (dst = buf; size; size--) {
const char *cp;
+ /* Fetch next source character, move the pointer on */
char ch = *src++;
+ /* Copy the current character to the destination */
*dst++ = ch;
- if ((ch != '$') || (size < 6) || memcmp("ident", src, 5))
+ /* If the current character is "$" or there are less than three
+ * remaining bytes or the two bytes following this one are not
+ * "Id", then simply read the next character */
+ if ((ch != '$') || (size < 3) || memcmp("Id", src, 2))
continue;
+ /*
+ * Here when
+ * - There are more than 2 bytes remaining
+ * - The current three bytes are "$Id"
+ * with
+ * - ch == "$"
+ * - src[0] == "I"
+ */
+
+ /*
+ * It's possible that an expanded Id has crept its way into the
+ * repository, we cope with that by stripping the expansion out
+ */
+ if (src[2] == ':') {
+ /* Expanded keywords have "$Id:" at the front */
- if (src[5] == ':') {
/* discard up to but not including the closing $ */
- unsigned long rem = size - 6;
- cp = src + 6;
+ unsigned long rem = size - 3;
+ /* Point at first byte after the ":" */
+ cp = src + 3;
+ /*
+ * Throw away characters until either
+ * - we reach a "$"
+ * - we run out of bytes (rem == 0)
+ */
do {
- ch = *cp++;
+ ch = *cp;
if (ch == '$')
break;
+ cp++;
rem--;
} while (rem);
+ /* If the above finished because it ran out of characters, then
+ * this is an incomplete keyword, so don't run the expansion */
if (!rem)
continue;
- size -= (cp - src);
- } else if (src[5] == '$')
- cp = src + 5;
+ } else if (src[2] == '$')
+ cp = src + 2;
else
+ /* Anything other than "$Id:XXX$" or $Id$ and we skip the
+ * expansion */
continue;
- memcpy(dst, "ident: ", 7);
- dst += 7;
+ /* cp is now pointing at the last $ of the keyword */
+
+ memcpy(dst, "Id: ", 4);
+ dst += 4;
memcpy(dst, sha1_to_hex(sha1), 40);
dst += 40;
*dst++ = ' ';
+
+ /* Adjust for the characters we've discarded */
size -= (cp - src);
src = cp;
+
+ /* Copy the final "$" */
*dst++ = *src++;
size--;
}
return buf;
}
+
+void *convert_sha1_file(const char *path, const unsigned char *sha1,
+ unsigned int mode, enum object_type *type,
+ unsigned long *size)
+{
+ void *buffer = read_sha1_file(sha1, type, size);
+ if (S_ISREG(mode) && buffer) {
+ void *converted = convert_to_working_tree(path, buffer, size);
+ if (converted) {
+ free(buffer);
+ buffer = converted;
+ }
+ }
+ return buffer;
+}