зеркало из https://github.com/microsoft/git.git
Rewrite convert_to_{git,working_tree} to use strbuf's.
* Now, those functions take an "out" strbuf argument, where they store their
result if any. In that case, it also returns 1, else it returns 0.
* those functions support "in place" editing, in the sense that it's OK to
call them this way:
convert_to_git(path, sb->buf, sb->len, sb);
When doable, conversions are done in place for real, else the strbuf
content is just replaced with the new one, transparentely for the caller.
If you want to create a new filter working this way, being the accumulation
of filter1, filter2, ... filtern, then your meta_filter would be:
int meta_filter(..., const char *src, size_t len, struct strbuf *sb)
{
int ret = 0;
ret |= filter1(...., src, len, sb);
if (ret) {
src = sb->buf;
len = sb->len;
}
ret |= filter2(...., src, len, sb);
if (ret) {
src = sb->buf;
len = sb->len;
}
....
return ret | filtern(..., src, len, sb);
}
That's why subfilters the convert_to_* functions called were also rewritten
to work this way.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Pierre Habouzit
Junio C Hamano
Родитель
917c9a7133
Коммит
5ecd293d14
|
|
@ -1446,8 +1446,7 @@ static int read_old_data(struct stat *st, const char *path, char **buf_p, unsign
|
|||
{
|
||||
int fd;
|
||||
unsigned long got;
|
||||
unsigned long nsize;
|
||||
char *nbuf;
|
||||
struct strbuf nbuf;
|
||||
unsigned long size = *size_p;
|
||||
char *buf = *buf_p;
|
||||
|
||||
|
|
@ -1466,13 +1465,12 @@ static int read_old_data(struct stat *st, const char *path, char **buf_p, unsign
|
|||
got += ret;
|
||||
}
|
||||
close(fd);
|
||||
nsize = got;
|
||||
nbuf = convert_to_git(path, buf, &nsize);
|
||||
if (nbuf) {
|
||||
strbuf_init(&nbuf, 0);
|
||||
if (convert_to_git(path, buf, size, &nbuf)) {
|
||||
free(buf);
|
||||
*buf_p = nbuf;
|
||||
*alloc_p = nsize;
|
||||
*size_p = nsize;
|
||||
*buf_p = nbuf.buf;
|
||||
*alloc_p = nbuf.alloc;
|
||||
*size_p = nbuf.len;
|
||||
}
|
||||
return got != size;
|
||||
default:
|
||||
|
|
@ -2439,7 +2437,7 @@ static void add_index_file(const char *path, unsigned mode, void *buf, unsigned
|
|||
static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)
|
||||
{
|
||||
int fd;
|
||||
char *nbuf;
|
||||
struct strbuf nbuf;
|
||||
|
||||
if (S_ISGITLINK(mode)) {
|
||||
struct stat st;
|
||||
|
|
@ -2458,9 +2456,11 @@ static int try_create_file(const char *path, unsigned int mode, const char *buf,
|
|||
if (fd < 0)
|
||||
return -1;
|
||||
|
||||
nbuf = convert_to_working_tree(path, buf, &size);
|
||||
if (nbuf)
|
||||
buf = nbuf;
|
||||
strbuf_init(&nbuf, 0);
|
||||
if (convert_to_working_tree(path, buf, size, &nbuf)) {
|
||||
size = nbuf.len;
|
||||
buf = nbuf.buf;
|
||||
}
|
||||
|
||||
while (size) {
|
||||
int written = xwrite(fd, buf, size);
|
||||
|
|
@ -2473,8 +2473,7 @@ static int try_create_file(const char *path, unsigned int mode, const char *buf,
|
|||
}
|
||||
if (close(fd) < 0)
|
||||
die("closing file %s: %s", path, strerror(errno));
|
||||
if (nbuf)
|
||||
free(nbuf);
|
||||
strbuf_release(&nbuf);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -81,22 +81,21 @@ static int run_remote_archiver(const char *remote, int argc,
|
|||
return !!rv;
|
||||
}
|
||||
|
||||
static void *format_subst(const struct commit *commit, const char *format,
|
||||
unsigned long *sizep)
|
||||
static void format_subst(const struct commit *commit,
|
||||
const char *src, size_t len,
|
||||
struct strbuf *buf)
|
||||
{
|
||||
unsigned long len = *sizep;
|
||||
const char *a = format;
|
||||
struct strbuf result;
|
||||
char *to_free = NULL;
|
||||
struct strbuf fmt;
|
||||
|
||||
strbuf_init(&result, 0);
|
||||
if (src == buf->buf)
|
||||
to_free = strbuf_detach(buf);
|
||||
strbuf_init(&fmt, 0);
|
||||
|
||||
for (;;) {
|
||||
const char *b, *c;
|
||||
|
||||
b = memmem(a, len, "$Format:", 8);
|
||||
if (!b || a + len < b + 9)
|
||||
b = memmem(src, len, "$Format:", 8);
|
||||
if (!b || src + len < b + 9)
|
||||
break;
|
||||
c = memchr(b + 8, '$', len - 8);
|
||||
if (!c)
|
||||
|
|
@ -105,62 +104,57 @@ static void *format_subst(const struct commit *commit, const char *format,
|
|||
strbuf_reset(&fmt);
|
||||
strbuf_add(&fmt, b + 8, c - b - 8);
|
||||
|
||||
strbuf_add(&result, a, b - a);
|
||||
format_commit_message(commit, fmt.buf, &result);
|
||||
len -= c + 1 - a;
|
||||
a = c + 1;
|
||||
strbuf_add(buf, src, b - src);
|
||||
format_commit_message(commit, fmt.buf, buf);
|
||||
len -= c + 1 - src;
|
||||
src = c + 1;
|
||||
}
|
||||
|
||||
strbuf_add(&result, a, len);
|
||||
|
||||
*sizep = result.len;
|
||||
|
||||
strbuf_add(buf, src, len);
|
||||
strbuf_release(&fmt);
|
||||
return strbuf_detach(&result);
|
||||
free(to_free);
|
||||
}
|
||||
|
||||
static void *convert_to_archive(const char *path,
|
||||
const void *src, unsigned long *sizep,
|
||||
const struct commit *commit)
|
||||
static int convert_to_archive(const char *path,
|
||||
const void *src, size_t len,
|
||||
struct strbuf *buf,
|
||||
const struct commit *commit)
|
||||
{
|
||||
static struct git_attr *attr_export_subst;
|
||||
struct git_attr_check check[1];
|
||||
|
||||
if (!commit)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
if (!attr_export_subst)
|
||||
attr_export_subst = git_attr("export-subst", 12);
|
||||
if (!attr_export_subst)
|
||||
attr_export_subst = git_attr("export-subst", 12);
|
||||
|
||||
check[0].attr = attr_export_subst;
|
||||
if (git_checkattr(path, ARRAY_SIZE(check), check))
|
||||
return NULL;
|
||||
return 0;
|
||||
if (!ATTR_TRUE(check[0].value))
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
return format_subst(commit, src, sizep);
|
||||
format_subst(commit, src, len, buf);
|
||||
return 1;
|
||||
}
|
||||
|
||||
void *sha1_file_to_archive(const char *path, const unsigned char *sha1,
|
||||
unsigned int mode, enum object_type *type,
|
||||
unsigned long *size,
|
||||
unsigned long *sizep,
|
||||
const struct commit *commit)
|
||||
{
|
||||
void *buffer, *converted;
|
||||
void *buffer;
|
||||
|
||||
buffer = read_sha1_file(sha1, type, size);
|
||||
buffer = read_sha1_file(sha1, type, sizep);
|
||||
if (buffer && S_ISREG(mode)) {
|
||||
converted = convert_to_working_tree(path, buffer, size);
|
||||
if (converted) {
|
||||
free(buffer);
|
||||
buffer = converted;
|
||||
}
|
||||
struct strbuf buf;
|
||||
|
||||
converted = convert_to_archive(path, buffer, size, commit);
|
||||
if (converted) {
|
||||
free(buffer);
|
||||
buffer = converted;
|
||||
}
|
||||
strbuf_init(&buf, 0);
|
||||
strbuf_attach(&buf, buffer, *sizep, *sizep + 1);
|
||||
convert_to_working_tree(path, buf.buf, buf.len, &buf);
|
||||
convert_to_archive(path, buf.buf, buf.len, &buf, commit);
|
||||
*sizep = buf.len;
|
||||
buffer = buf.buf;
|
||||
}
|
||||
|
||||
return buffer;
|
||||
|
|
|
|||
6
cache.h
6
cache.h
|
|
@ -2,6 +2,7 @@
|
|||
#define CACHE_H
|
||||
|
||||
#include "git-compat-util.h"
|
||||
#include "strbuf.h"
|
||||
|
||||
#include SHA1_HEADER
|
||||
#include <zlib.h>
|
||||
|
|
@ -589,8 +590,9 @@ extern void trace_printf(const char *format, ...);
|
|||
extern void trace_argv_printf(const char **argv, int count, const char *format, ...);
|
||||
|
||||
/* convert.c */
|
||||
extern char *convert_to_git(const char *path, const char *src, unsigned long *sizep);
|
||||
extern char *convert_to_working_tree(const char *path, const char *src, unsigned long *sizep);
|
||||
/* returns 1 if *dst was used */
|
||||
extern int convert_to_git(const char *path, const char *src, size_t len, struct strbuf *dst);
|
||||
extern int convert_to_working_tree(const char *path, const char *src, size_t len, struct strbuf *dst);
|
||||
|
||||
/* diff.c */
|
||||
extern int diff_auto_refresh_index;
|
||||
|
|
|
|||
406
convert.c
406
convert.c
|
|
@ -1,6 +1,7 @@
|
|||
#include "cache.h"
|
||||
#include "attr.h"
|
||||
#include "run-command.h"
|
||||
#include "strbuf.h"
|
||||
|
||||
/*
|
||||
* convert.c - convert a file when checking it out and checking it in.
|
||||
|
|
@ -80,24 +81,19 @@ static int is_binary(unsigned long size, struct text_stat *stats)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static char *crlf_to_git(const char *path, const char *src, unsigned long *sizep, int action)
|
||||
static int crlf_to_git(const char *path, const char *src, size_t len,
|
||||
struct strbuf *buf, int action)
|
||||
{
|
||||
char *buffer, *dst;
|
||||
unsigned long size, nsize;
|
||||
struct text_stat stats;
|
||||
char *dst;
|
||||
|
||||
if ((action == CRLF_BINARY) || !auto_crlf)
|
||||
return NULL;
|
||||
|
||||
size = *sizep;
|
||||
if (!size)
|
||||
return NULL;
|
||||
|
||||
gather_stats(src, size, &stats);
|
||||
if ((action == CRLF_BINARY) || !auto_crlf || !len)
|
||||
return 0;
|
||||
|
||||
gather_stats(src, len, &stats);
|
||||
/* No CR? Nothing to convert, regardless. */
|
||||
if (!stats.cr)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
if (action == CRLF_GUESS) {
|
||||
/*
|
||||
|
|
@ -106,24 +102,17 @@ static char *crlf_to_git(const char *path, const char *src, unsigned long *sizep
|
|||
* stuff?
|
||||
*/
|
||||
if (stats.cr != stats.crlf)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* And add some heuristics for binary vs text, of course...
|
||||
*/
|
||||
if (is_binary(size, &stats))
|
||||
return NULL;
|
||||
if (is_binary(len, &stats))
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ok, allocate a new buffer, fill it in, and return it
|
||||
* to let the caller know that we switched buffers.
|
||||
*/
|
||||
nsize = size - stats.crlf;
|
||||
buffer = xmalloc(nsize);
|
||||
*sizep = nsize;
|
||||
|
||||
dst = buffer;
|
||||
strbuf_grow(buf, len);
|
||||
dst = buf->buf;
|
||||
if (action == CRLF_GUESS) {
|
||||
/*
|
||||
* If we guessed, we already know we rejected a file with
|
||||
|
|
@ -134,71 +123,72 @@ static char *crlf_to_git(const char *path, const char *src, unsigned long *sizep
|
|||
unsigned char c = *src++;
|
||||
if (c != '\r')
|
||||
*dst++ = c;
|
||||
} while (--size);
|
||||
} while (--len);
|
||||
} else {
|
||||
do {
|
||||
unsigned char c = *src++;
|
||||
if (! (c == '\r' && (1 < size && *src == '\n')))
|
||||
if (! (c == '\r' && (1 < len && *src == '\n')))
|
||||
*dst++ = c;
|
||||
} while (--size);
|
||||
} while (--len);
|
||||
}
|
||||
|
||||
return buffer;
|
||||
strbuf_setlen(buf, dst - buf->buf);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static char *crlf_to_worktree(const char *path, const char *src, unsigned long *sizep, int action)
|
||||
static int crlf_to_worktree(const char *path, const char *src, size_t len,
|
||||
struct strbuf *buf, int action)
|
||||
{
|
||||
char *buffer, *dst;
|
||||
unsigned long size, nsize;
|
||||
char *to_free = NULL;
|
||||
struct text_stat stats;
|
||||
unsigned char last;
|
||||
|
||||
if ((action == CRLF_BINARY) || (action == CRLF_INPUT) ||
|
||||
auto_crlf <= 0)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
size = *sizep;
|
||||
if (!size)
|
||||
return NULL;
|
||||
if (!len)
|
||||
return 0;
|
||||
|
||||
gather_stats(src, size, &stats);
|
||||
gather_stats(src, len, &stats);
|
||||
|
||||
/* No LF? Nothing to convert, regardless. */
|
||||
if (!stats.lf)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
/* Was it already in CRLF format? */
|
||||
if (stats.lf == stats.crlf)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
if (action == CRLF_GUESS) {
|
||||
/* If we have any bare CR characters, we're not going to touch it */
|
||||
if (stats.cr != stats.crlf)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
if (is_binary(size, &stats))
|
||||
return NULL;
|
||||
if (is_binary(len, &stats))
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ok, allocate a new buffer, fill it in, and return it
|
||||
* to let the caller know that we switched buffers.
|
||||
*/
|
||||
nsize = size + stats.lf - stats.crlf;
|
||||
buffer = xmalloc(nsize);
|
||||
*sizep = nsize;
|
||||
last = 0;
|
||||
/* are we "faking" in place editing ? */
|
||||
if (src == buf->buf)
|
||||
to_free = strbuf_detach(buf);
|
||||
|
||||
dst = buffer;
|
||||
do {
|
||||
unsigned char c = *src++;
|
||||
if (c == '\n' && last != '\r')
|
||||
*dst++ = '\r';
|
||||
*dst++ = c;
|
||||
last = c;
|
||||
} while (--size);
|
||||
strbuf_grow(buf, len + stats.lf - stats.crlf);
|
||||
for (;;) {
|
||||
const char *nl = memchr(src, '\n', len);
|
||||
if (!nl)
|
||||
break;
|
||||
if (nl > src && nl[-1] == '\r') {
|
||||
strbuf_add(buf, src, nl + 1 - src);
|
||||
} else {
|
||||
strbuf_add(buf, src, nl - src);
|
||||
strbuf_addstr(buf, "\r\n");
|
||||
}
|
||||
len -= nl + 1 - src;
|
||||
src = nl + 1;
|
||||
}
|
||||
strbuf_add(buf, src, len);
|
||||
|
||||
return buffer;
|
||||
free(to_free);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int filter_buffer(const char *path, const char *src,
|
||||
|
|
@ -246,8 +236,8 @@ static int filter_buffer(const char *path, const char *src,
|
|||
return (write_err || status);
|
||||
}
|
||||
|
||||
static char *apply_filter(const char *path, const char *src,
|
||||
unsigned long *sizep, const char *cmd)
|
||||
static int apply_filter(const char *path, const char *src, size_t len,
|
||||
struct strbuf *dst, const char *cmd)
|
||||
{
|
||||
/*
|
||||
* Create a pipeline to have the command filter the buffer's
|
||||
|
|
@ -255,21 +245,19 @@ static char *apply_filter(const char *path, const char *src,
|
|||
*
|
||||
* (child --> cmd) --> us
|
||||
*/
|
||||
const int SLOP = 4096;
|
||||
int pipe_feed[2];
|
||||
int status;
|
||||
char *dst;
|
||||
unsigned long dstsize, dstalloc;
|
||||
int status, ret = 1;
|
||||
struct child_process child_process;
|
||||
struct strbuf nbuf;
|
||||
|
||||
if (!cmd)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
memset(&child_process, 0, sizeof(child_process));
|
||||
|
||||
if (pipe(pipe_feed) < 0) {
|
||||
error("cannot create pipe to run external filter %s", cmd);
|
||||
return NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
fflush(NULL);
|
||||
|
|
@ -278,54 +266,37 @@ static char *apply_filter(const char *path, const char *src,
|
|||
error("cannot fork to run external filter %s", cmd);
|
||||
close(pipe_feed[0]);
|
||||
close(pipe_feed[1]);
|
||||
return NULL;
|
||||
return 0;
|
||||
}
|
||||
if (!child_process.pid) {
|
||||
dup2(pipe_feed[1], 1);
|
||||
close(pipe_feed[0]);
|
||||
close(pipe_feed[1]);
|
||||
exit(filter_buffer(path, src, *sizep, cmd));
|
||||
exit(filter_buffer(path, src, len, cmd));
|
||||
}
|
||||
close(pipe_feed[1]);
|
||||
|
||||
dstalloc = *sizep;
|
||||
dst = xmalloc(dstalloc);
|
||||
dstsize = 0;
|
||||
|
||||
while (1) {
|
||||
ssize_t numread = xread(pipe_feed[0], dst + dstsize,
|
||||
dstalloc - dstsize);
|
||||
|
||||
if (numread <= 0) {
|
||||
if (!numread)
|
||||
break;
|
||||
error("read from external filter %s failed", cmd);
|
||||
free(dst);
|
||||
dst = NULL;
|
||||
break;
|
||||
}
|
||||
dstsize += numread;
|
||||
if (dstalloc <= dstsize + SLOP) {
|
||||
dstalloc = dstsize + SLOP;
|
||||
dst = xrealloc(dst, dstalloc);
|
||||
}
|
||||
strbuf_init(&nbuf, 0);
|
||||
if (strbuf_read(&nbuf, pipe_feed[0], len) < 0) {
|
||||
error("read from external filter %s failed", cmd);
|
||||
ret = 0;
|
||||
}
|
||||
if (close(pipe_feed[0])) {
|
||||
error("read from external filter %s failed", cmd);
|
||||
free(dst);
|
||||
dst = NULL;
|
||||
ret = error("read from external filter %s failed", cmd);
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
status = finish_command(&child_process);
|
||||
if (status) {
|
||||
error("external filter %s failed %d", cmd, -status);
|
||||
free(dst);
|
||||
dst = NULL;
|
||||
ret = error("external filter %s failed %d", cmd, -status);
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
if (dst)
|
||||
*sizep = dstsize;
|
||||
return dst;
|
||||
if (ret) {
|
||||
*dst = nbuf;
|
||||
} else {
|
||||
strbuf_release(&nbuf);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct convert_driver {
|
||||
|
|
@ -449,137 +420,104 @@ static int count_ident(const char *cp, unsigned long size)
|
|||
return cnt;
|
||||
}
|
||||
|
||||
static char *ident_to_git(const char *path, const char *src, unsigned long *sizep, int ident)
|
||||
static int ident_to_git(const char *path, const char *src, size_t len,
|
||||
struct strbuf *buf, int ident)
|
||||
{
|
||||
int cnt;
|
||||
unsigned long size;
|
||||
char *dst, *buf;
|
||||
char *dst, *dollar;
|
||||
|
||||
if (!ident)
|
||||
return NULL;
|
||||
size = *sizep;
|
||||
cnt = count_ident(src, size);
|
||||
if (!cnt)
|
||||
return NULL;
|
||||
buf = xmalloc(size);
|
||||
if (!ident || !count_ident(src, len))
|
||||
return 0;
|
||||
|
||||
for (dst = buf; size; size--) {
|
||||
char ch = *src++;
|
||||
*dst++ = ch;
|
||||
if ((ch == '$') && (3 <= size) &&
|
||||
!memcmp("Id:", src, 3)) {
|
||||
unsigned long rem = size - 3;
|
||||
const char *cp = src + 3;
|
||||
do {
|
||||
ch = *cp++;
|
||||
if (ch == '$')
|
||||
break;
|
||||
rem--;
|
||||
} while (rem);
|
||||
if (!rem)
|
||||
continue;
|
||||
strbuf_grow(buf, len);
|
||||
dst = buf->buf;
|
||||
for (;;) {
|
||||
dollar = memchr(src, '$', len);
|
||||
if (!dollar)
|
||||
break;
|
||||
memcpy(dst, src, dollar + 1 - src);
|
||||
dst += dollar + 1 - src;
|
||||
len -= dollar + 1 - src;
|
||||
src = dollar + 1;
|
||||
|
||||
if (len > 3 && !memcmp(src, "Id:", 3)) {
|
||||
dollar = memchr(src + 3, '$', len - 3);
|
||||
if (!dollar)
|
||||
break;
|
||||
memcpy(dst, "Id$", 3);
|
||||
dst += 3;
|
||||
size -= (cp - src);
|
||||
src = cp;
|
||||
len -= dollar + 1 - src;
|
||||
src = dollar + 1;
|
||||
}
|
||||
}
|
||||
|
||||
*sizep = dst - buf;
|
||||
return buf;
|
||||
memcpy(dst, src, len);
|
||||
strbuf_setlen(buf, dst + len - buf->buf);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static char *ident_to_worktree(const char *path, const char *src, unsigned long *sizep, int ident)
|
||||
static int ident_to_worktree(const char *path, const char *src, size_t len,
|
||||
struct strbuf *buf, int ident)
|
||||
{
|
||||
int cnt;
|
||||
unsigned long size;
|
||||
char *dst, *buf;
|
||||
unsigned char sha1[20];
|
||||
char *to_free = NULL, *dollar;
|
||||
int cnt;
|
||||
|
||||
if (!ident)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
size = *sizep;
|
||||
cnt = count_ident(src, size);
|
||||
cnt = count_ident(src, len);
|
||||
if (!cnt)
|
||||
return NULL;
|
||||
return 0;
|
||||
|
||||
hash_sha1_file(src, size, "blob", sha1);
|
||||
buf = xmalloc(size + cnt * 43);
|
||||
/* are we "faking" in place editing ? */
|
||||
if (src == buf->buf)
|
||||
to_free = strbuf_detach(buf);
|
||||
hash_sha1_file(src, len, "blob", sha1);
|
||||
|
||||
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 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))
|
||||
strbuf_grow(buf, len + cnt * 43);
|
||||
for (;;) {
|
||||
/* step 1: run to the next '$' */
|
||||
dollar = memchr(src, '$', len);
|
||||
if (!dollar)
|
||||
break;
|
||||
strbuf_add(buf, src, dollar + 1 - src);
|
||||
len -= dollar + 1 - src;
|
||||
src = dollar + 1;
|
||||
|
||||
/* step 2: does it looks like a bit like Id:xxx$ or Id$ ? */
|
||||
if (len < 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 */
|
||||
|
||||
/* discard up to but not including the closing $ */
|
||||
unsigned long rem = size - 3;
|
||||
/* Point at first byte after the ":" */
|
||||
cp = src + 3;
|
||||
/* step 3: skip over Id$ or Id:xxxxx$ */
|
||||
if (src[2] == '$') {
|
||||
src += 3;
|
||||
len -= 3;
|
||||
} else if (src[2] == ':') {
|
||||
/*
|
||||
* Throw away characters until either
|
||||
* - we reach a "$"
|
||||
* - we run out of bytes (rem == 0)
|
||||
* It's possible that an expanded Id has crept its way into the
|
||||
* repository, we cope with that by stripping the expansion out
|
||||
*/
|
||||
do {
|
||||
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;
|
||||
} else if (src[2] == '$')
|
||||
cp = src + 2;
|
||||
else
|
||||
/* Anything other than "$Id:XXX$" or $Id$ and we skip the
|
||||
* expansion */
|
||||
dollar = memchr(src + 3, '$', len - 3);
|
||||
if (!dollar) {
|
||||
/* incomplete keyword, no more '$', so just quit the loop */
|
||||
break;
|
||||
}
|
||||
|
||||
len -= dollar + 1 - src;
|
||||
src = dollar + 1;
|
||||
} else {
|
||||
/* it wasn't a "Id$" or "Id:xxxx$" */
|
||||
continue;
|
||||
}
|
||||
|
||||
/* 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--;
|
||||
/* step 4: substitute */
|
||||
strbuf_addstr(buf, "Id: ");
|
||||
strbuf_add(buf, sha1_to_hex(sha1), 40);
|
||||
strbuf_addstr(buf, " $");
|
||||
}
|
||||
strbuf_add(buf, src, len);
|
||||
|
||||
*sizep = dst - buf;
|
||||
return buf;
|
||||
free(to_free);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int git_path_check_crlf(const char *path, struct git_attr_check *check)
|
||||
|
|
@ -618,13 +556,12 @@ static int git_path_check_ident(const char *path, struct git_attr_check *check)
|
|||
return !!ATTR_TRUE(value);
|
||||
}
|
||||
|
||||
char *convert_to_git(const char *path, const char *src, unsigned long *sizep)
|
||||
int convert_to_git(const char *path, const char *src, size_t len, struct strbuf *dst)
|
||||
{
|
||||
struct git_attr_check check[3];
|
||||
int crlf = CRLF_GUESS;
|
||||
int ident = 0;
|
||||
int ident = 0, ret = 0;
|
||||
char *filter = NULL;
|
||||
char *buf, *buf2;
|
||||
|
||||
setup_convert_check(check);
|
||||
if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
|
||||
|
|
@ -636,30 +573,25 @@ char *convert_to_git(const char *path, const char *src, unsigned long *sizep)
|
|||
filter = drv->clean;
|
||||
}
|
||||
|
||||
buf = apply_filter(path, src, sizep, filter);
|
||||
|
||||
buf2 = crlf_to_git(path, buf ? buf : src, sizep, crlf);
|
||||
if (buf2) {
|
||||
free(buf);
|
||||
buf = buf2;
|
||||
ret |= apply_filter(path, src, len, dst, filter);
|
||||
if (ret) {
|
||||
src = dst->buf;
|
||||
len = dst->len;
|
||||
}
|
||||
|
||||
buf2 = ident_to_git(path, buf ? buf : src, sizep, ident);
|
||||
if (buf2) {
|
||||
free(buf);
|
||||
buf = buf2;
|
||||
ret |= crlf_to_git(path, src, len, dst, crlf);
|
||||
if (ret) {
|
||||
src = dst->buf;
|
||||
len = dst->len;
|
||||
}
|
||||
|
||||
return buf;
|
||||
return ret | ident_to_git(path, src, len, dst, ident);
|
||||
}
|
||||
|
||||
char *convert_to_working_tree(const char *path, const char *src, unsigned long *sizep)
|
||||
int convert_to_working_tree(const char *path, const char *src, size_t len, struct strbuf *dst)
|
||||
{
|
||||
struct git_attr_check check[3];
|
||||
int crlf = CRLF_GUESS;
|
||||
int ident = 0;
|
||||
int ident = 0, ret = 0;
|
||||
char *filter = NULL;
|
||||
char *buf, *buf2;
|
||||
|
||||
setup_convert_check(check);
|
||||
if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
|
||||
|
|
@ -671,19 +603,15 @@ char *convert_to_working_tree(const char *path, const char *src, unsigned long *
|
|||
filter = drv->smudge;
|
||||
}
|
||||
|
||||
buf = ident_to_worktree(path, src, sizep, ident);
|
||||
|
||||
buf2 = crlf_to_worktree(path, buf ? buf : src, sizep, crlf);
|
||||
if (buf2) {
|
||||
free(buf);
|
||||
buf = buf2;
|
||||
ret |= ident_to_worktree(path, src, len, dst, ident);
|
||||
if (ret) {
|
||||
src = dst->buf;
|
||||
len = dst->len;
|
||||
}
|
||||
|
||||
buf2 = apply_filter(path, buf ? buf : src, sizep, filter);
|
||||
if (buf2) {
|
||||
free(buf);
|
||||
buf = buf2;
|
||||
ret |= crlf_to_worktree(path, src, len, dst, crlf);
|
||||
if (ret) {
|
||||
src = dst->buf;
|
||||
len = dst->len;
|
||||
}
|
||||
|
||||
return buf;
|
||||
return ret | apply_filter(path, src, len, dst, filter);
|
||||
}
|
||||
|
|
|
|||
12
diff.c
12
diff.c
|
|
@ -1600,10 +1600,9 @@ int diff_populate_filespec(struct diff_filespec *s, int size_only)
|
|||
|
||||
if (!s->sha1_valid ||
|
||||
reuse_worktree_file(s->path, s->sha1, 0)) {
|
||||
struct strbuf buf;
|
||||
struct stat st;
|
||||
int fd;
|
||||
char *buf;
|
||||
unsigned long size;
|
||||
|
||||
if (!strcmp(s->path, "-"))
|
||||
return populate_from_stdin(s);
|
||||
|
|
@ -1644,13 +1643,12 @@ int diff_populate_filespec(struct diff_filespec *s, int size_only)
|
|||
/*
|
||||
* Convert from working tree format to canonical git format
|
||||
*/
|
||||
size = s->size;
|
||||
buf = convert_to_git(s->path, s->data, &size);
|
||||
if (buf) {
|
||||
strbuf_init(&buf, 0);
|
||||
if (convert_to_git(s->path, s->data, s->size, &buf)) {
|
||||
munmap(s->data, s->size);
|
||||
s->should_munmap = 0;
|
||||
s->data = buf;
|
||||
s->size = size;
|
||||
s->data = buf.buf;
|
||||
s->size = buf.len;
|
||||
s->should_free = 1;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
10
entry.c
10
entry.c
|
|
@ -104,7 +104,8 @@ static int write_entry(struct cache_entry *ce, char *path, const struct checkout
|
|||
long wrote;
|
||||
|
||||
switch (ntohl(ce->ce_mode) & S_IFMT) {
|
||||
char *buf, *new;
|
||||
char *new;
|
||||
struct strbuf buf;
|
||||
unsigned long size;
|
||||
|
||||
case S_IFREG:
|
||||
|
|
@ -116,10 +117,11 @@ static int write_entry(struct cache_entry *ce, char *path, const struct checkout
|
|||
/*
|
||||
* Convert from git internal format to working tree format
|
||||
*/
|
||||
buf = convert_to_working_tree(ce->name, new, &size);
|
||||
if (buf) {
|
||||
strbuf_init(&buf, 0);
|
||||
if (convert_to_working_tree(ce->name, new, size, &buf)) {
|
||||
free(new);
|
||||
new = buf;
|
||||
new = buf.buf;
|
||||
size = buf.len;
|
||||
}
|
||||
|
||||
if (to_tempfile) {
|
||||
|
|
|
|||
10
sha1_file.c
10
sha1_file.c
|
|
@ -2343,12 +2343,12 @@ int index_fd(unsigned char *sha1, int fd, struct stat *st, int write_object,
|
|||
* Convert blobs to git internal format
|
||||
*/
|
||||
if ((type == OBJ_BLOB) && S_ISREG(st->st_mode)) {
|
||||
unsigned long nsize = size;
|
||||
char *nbuf = convert_to_git(path, buf, &nsize);
|
||||
if (nbuf) {
|
||||
struct strbuf nbuf;
|
||||
strbuf_init(&nbuf, 0);
|
||||
if (convert_to_git(path, buf, size, &nbuf)) {
|
||||
munmap(buf, size);
|
||||
size = nsize;
|
||||
buf = nbuf;
|
||||
size = nbuf.len;
|
||||
buf = nbuf.buf;
|
||||
re_allocated = 1;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче