undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'np/delta' into next

Browse Source 
* np/delta:
  split the diff-delta interface
  Document the configuration file
  Document git-var -l listing also configuration variables
  rev-parse: better error message for ambiguous arguments
This commit is contained in:
Junio C Hamano 2006-04-24 22:31:15 -07:00
commit 5a6a8c0e01
8 changed files with 367 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

181
Documentation/config.txt Normal file
View File

@ -0,0 +1,181 @@
CONFIGURATION FILE
------------------
The git configuration file contains a number of variables that affect
the git commands behaviour. They can be used by both the git plumbing
and the porcelains. The variables are divided to sections, where
in the fully qualified variable name the variable itself is the last
dot-separated segment and the section name is everything before the last
dot. The variable names are case-insensitive and only alphanumeric
characters are allowed. Some variables may appear multiple times.
The syntax is fairly flexible and permissive; whitespaces are mostly
ignored. The '#' and ';' characters begin commends to the end of line,
blank lines are ignored, lines containing strings enclosed in square
brackets start sections and all the other lines are recognized
as setting variables, in the form 'name = value'. If there is no equal
sign on the line, the entire line is taken as 'name' and the variable
is recognized as boolean "true". String values may be entirely or partially
enclosed in double quotes; some variables may require special value format.
Example
~~~~~~~
# Core variables
[core]
; Don't trust file modes
filemode = false
# Our diff algorithm
[diff]
external = "/usr/local/bin/gnu-diff -u"
renames = true
Variables
~~~~~~~~~
Note that this list is non-comprehensive and not necessarily complete.
For command-specific variables, you will find more detailed description
in the appropriate manual page. You will find description of non-core
porcelain configuration variables in the respective porcelain documentation.
core.fileMode::
If false, the executable bit differences between the index and
the working copy are ignored; useful on broken filesystems like FAT.
See gitlink:git-update-index[1]. True by default.
core.gitProxy::
A "proxy command" to execute (as 'command host port') instead
of establishing direct connection to the remote server when
using the git protocol for fetching. If the variable value is
in the "COMMAND for DOMAIN" format, the command is applied only
on hostnames ending with the specified domain string. This variable
may be set multiple times and is matched in the given order;
the first match wins.
Can be overriden by the 'GIT_PROXY_COMMAND' environment variable
(which always applies universally, without the special "for"
handling).
core.ignoreStat::
The working copy files are assumed to stay unchanged until you
mark them otherwise manually - Git will not detect the file changes
by lstat() calls. This is useful on systems where those are very
slow, such as Microsoft Windows. See gitlink:git-update-index[1].
False by default.
core.onlyUseSymrefs::
Always use the "symref" format instead of symbolic links for HEAD
and other symbolic reference files. True by default.
core.repositoryFormatVersion::
Internal variable identifying the repository format and layout
version.
core.sharedRepository::
If true, the repository is made shareable between several users
in a group (making sure all the files and objects are group-writable).
See gitlink:git-init-db[1]. False by default.
core.warnAmbiguousRefs::
If true, git will warn you if the ref name you passed it is ambiguous
and might match multiple refs in the .git/refs/ tree. True by default.
apply.whitespace::
Tells `git-apply` how to handle whitespaces, in the same way
as the '--whitespace' option. See gitlink:git-apply[1].
diff.renameLimit::
The number of files to consider when performing the copy/rename
detection; equivalent to the git diff option '-l'.
format.headers::
Additional email headers to include in a patch to be submitted
by mail. See gitlink:git-format-patch[1].
gitcvs.enabled::
Whether the cvs pserver interface is enabled for this repository.
See gitlink:git-cvsserver[1].
gitcvs.logfile::
Path to a log file where the cvs pserver interface well... logs
various stuff. See gitlink:git-cvsserver[1].
http.sslVerify::
Whether to verify the SSL certificate when fetching or pushing
over HTTPS. Can be overriden by the 'GIT_SSL_NO_VERIFY' environment
variable.
http.sslCert::
File containing the SSL certificate when fetching or pushing
over HTTPS. Can be overriden by the 'GIT_SSL_CERT' environment
variable.
http.sslKey::
File containing the SSL private key when fetching or pushing
over HTTPS. Can be overriden by the 'GIT_SSL_KEY' environment
variable.
http.sslCAInfo::
File containing the certificates to verify the peer with when
fetching or pushing over HTTPS. Can be overriden by the
'GIT_SSL_CAINFO' environment variable.
http.sslCAPath::
Path containing files with the CA certificates to verify the peer
with when fetching or pushing over HTTPS. Can be overriden
by the 'GIT_SSL_CAPATH' environment variable.
http.maxRequests::
How many HTTP requests to launch in parallel. Can be overriden
by the 'GIT_HTTP_MAX_REQUESTS' environment variable. Default is 5.
http.lowSpeedLimit, http.lowSpeedTime::
If the HTTP transfer speed is less than 'http.lowSpeedLimit'
for longer than 'http.lowSpeedTime' seconds, the transfer is aborted.
Can be overriden by the 'GIT_HTTP_LOW_SPEED_LIMIT' and
'GIT_HTTP_LOW_SPEED_TIME' environment variables.
i18n.commitEncoding::
Character encoding the commit messages are stored in; git itself
does not care per se, but this information is necessary e.g. when
importing commits from emails or in the gitk graphical history
browser (and possibly at other places in the future or in other
porcelains). See e.g. gitlink:git-mailinfo[1]. Defaults to 'utf-8'.
merge.summary::
Whether to include summaries of merged commits in newly created
merge commit messages. False by default.
pull.octopus::
The default merge strategy to use when pulling multiple branches
at once.
pull.twohead::
The default merge strategy to use when pulling a single branch.
show.difftree::
The default gitlink:git-diff-tree[1] arguments to be used
for gitlink:git-show[1].
showbranch.default::
The default set of branches for gitlink:git-show-branch[1].
See gitlink:git-show-branch[1].
user.email::
Your email address to be recorded in any newly created commits.
Can be overriden by the 'GIT_AUTHOR_EMAIL' and 'GIT_COMMITTER_EMAIL'
environment variables. See gitlink:git-commit-tree[1].
user.name::
Your full name to be recorded in any newly created commits.
Can be overriden by the 'GIT_AUTHOR_NAME' and 'GIT_COMMITTER_NAME'
environment variables. See gitlink:git-commit-tree[1].
whatchanged.difftree::
The default gitlink:git-diff-tree[1] arguments to be used
for gitlink:git-whatchanged[1].
imap::
The configuration variables in the 'imap' section are described
in gitlink:git-imap-send[1].

29
Documentation/git-repo-config.txt
View File

@ -87,11 +87,11 @@ Given a .git/config like this:
renames = true
; Proxy settings
[proxy]
command="ssh" for "ssh://kernel.org/"
command="proxy-command" for kernel.org
command="myprotocol-command" for "my://"
command=default-proxy ; for all the rest
[core]
gitproxy="ssh" for "ssh://kernel.org/"
gitproxy="proxy-command" for kernel.org
gitproxy="myprotocol-command" for "my://"
gitproxy=default-proxy ; for all the rest
you can set the filemode to true with
@ -104,7 +104,7 @@ to what URL they apply. Here is how to change the entry for kernel.org
to "ssh".
------------
% git repo-config proxy.command '"ssh" for kernel.org' 'for kernel.org$'
% git repo-config core.gitproxy '"ssh" for kernel.org' 'for kernel.org$'
------------
This makes sure that only the key/value pair for kernel.org is replaced.
@ -115,7 +115,7 @@ To delete the entry for renames, do
% git repo-config --unset diff.renames
------------
If you want to delete an entry for a multivar (like proxy.command above),
If you want to delete an entry for a multivar (like core.gitproxy above),
you have to provide a regex matching the value of exactly one line.
To query the value for a given key, do
@ -133,27 +133,27 @@ or
or, to query a multivar:
------------
% git repo-config --get proxy.command "for kernel.org$"
% git repo-config --get core.gitproxy "for kernel.org$"
------------
If you want to know all the values for a multivar, do:
------------
% git repo-config --get-all proxy.command
% git repo-config --get-all core.gitproxy
------------
If you like to live dangerous, you can replace *all* proxy.commands by a
If you like to live dangerous, you can replace *all* core.gitproxy by a
new one with
------------
% git repo-config --replace-all proxy.command ssh
% git repo-config --replace-all core.gitproxy ssh
------------
However, if you really only want to replace the line for the default proxy,
i.e. the one without a "for ..." postfix, do something like this:
------------
% git repo-config proxy.command ssh '! for '
% git repo-config core.gitproxy ssh '! for '
------------
To actually match only values with an exclamation mark, you have to
@ -163,13 +163,16 @@ To actually match only values with an exclamation mark, you have to
------------
include::config.txt[]
Author
------
Written by Johannes Schindelin <Johannes.Schindelin@gmx.de>
Documentation
--------------
Documentation by Johannes Schindelin.
Documentation by Johannes Schindelin, Petr Baudis and the git-list <git@vger.kernel.org>.
GIT
---

5
Documentation/git-var.txt
View File

@ -17,7 +17,9 @@ Prints a git logical variable.
OPTIONS
-------
-l::
Cause the logical variables to be listed.
Cause the logical variables to be listed. In addition, all the
variables of the git configuration file .git/config are listed
as well.
EXAMPLE
--------
@ -46,6 +48,7 @@ See Also
--------
gitlink:git-commit-tree[1]
gitlink:git-tag[1]
gitlink:git-repo-config[1]
Author
------

2
config.c
View File

@ -252,7 +252,7 @@ int git_default_config(const char *var, const char *value)
return 0;
}
/* Add other config variables here.. */
/* Add other config variables here and to Documentation/config.txt. */
return 0;
}

75
delta.h
View File

@ -1,12 +1,73 @@
#ifndef DELTA_H
#define DELTA_H
/* handling of delta buffers */
extern void *diff_delta(void *from_buf, unsigned long from_size,
void *to_buf, unsigned long to_size,
unsigned long *delta_size, unsigned long max_size);
extern void *patch_delta(void *src_buf, unsigned long src_size,
void *delta_buf, unsigned long delta_size,
/* opaque object for delta index */
struct delta_index;
/*
* create_delta_index: compute index data from given buffer
*
* This returns a pointer to a struct delta_index that should be passed to
* subsequent create_delta() calls, or to free_delta_index(). A NULL pointer
* is returned on failure. The given buffer must not be freed nor altered
* before free_delta_index() is called. The returned pointer must be freed
* using free_delta_index().
*/
extern struct delta_index *
create_delta_index(const void *buf, unsigned long bufsize);
/*
* free_delta_index: free the index created by create_delta_index()
*/
extern void free_delta_index(struct delta_index *index);
/*
* create_delta: create a delta from given index for the given buffer
*
* This function may be called multiple times with different buffers using
* the same delta_index pointer. If max_delta_size is non-zero and the
* resulting delta is to be larger than max_delta_size then NULL is returned.
* On success, a non-NULL pointer to the buffer with the delta data is
* returned and *delta_size is updated with its size. The returned buffer
* must be freed by the caller.
*/
extern void *
create_delta(const struct delta_index *index,
const void *buf, unsigned long bufsize,
unsigned long *delta_size, unsigned long max_delta_size);
/*
* diff_delta: create a delta from source buffer to target buffer
*
* If max_delta_size is non-zero and the resulting delta is to be larger
* than max_delta_size then NULL is returned. On success, a non-NULL
* pointer to the buffer with the delta data is returned and *delta_size is
* updated with its size. The returned buffer must be freed by the caller.
*/
static inline void *
diff_delta(const void *src_buf, unsigned long src_bufsize,
const void *trg_buf, unsigned long trg_bufsize,
unsigned long *delta_size, unsigned long max_delta_size)
{
struct delta_index *index = create_delta_index(src_buf, src_bufsize);
if (index) {
void *delta = create_delta(index, trg_buf, trg_bufsize,
delta_size, max_delta_size);
free_delta_index(index);
return delta;
}
return NULL;
}
/*
* patch_delta: recreate target buffer given source buffer and delta data
*
* On success, a non-NULL pointer to the target buffer is returned and
* *trg_bufsize is updated with its size. On failure a NULL pointer is
* returned. The returned buffer must be freed by the caller.
*/
extern void *patch_delta(const void *src_buf, unsigned long src_size,
const void *delta_buf, unsigned long delta_size,
unsigned long *dst_size);
/* the smallest possible delta size is 4 bytes */
@ -14,7 +75,7 @@ extern void *patch_delta(void *src_buf, unsigned long src_size,
/*
* This must be called twice on the delta data buffer, first to get the
* expected reference buffer size, and again to get the result buffer size.
* expected source buffer size, and again to get the target buffer size.
*/
static inline unsigned long get_delta_hdr_size(const unsigned char **datap,
const unsigned char *top)

168
diff-delta.c
View File

@ -27,53 +27,70 @@
/* block size: min = 16, max = 64k, power of 2 */
#define BLK_SIZE 16
#define MIN(a, b) ((a) < (b) ? (a) : (b))
/* maximum hash entry list for the same hash bucket */
#define HASH_LIMIT 64
#define GR_PRIME 0x9e370001
#define HASH(v, shift) (((unsigned int)(v) * GR_PRIME) >> (shift))
struct index {
struct index_entry {
const unsigned char *ptr;
unsigned int val;
struct index *next;
struct index_entry *next;
};
static struct index ** delta_index(const unsigned char *buf,
unsigned long bufsize,
unsigned long trg_bufsize,
unsigned int *hash_shift)
struct delta_index {
const void *src_buf;
unsigned long src_size;
unsigned int hash_shift;
struct index_entry *hash[0];
};
struct delta_index * create_delta_index(const void *buf, unsigned long bufsize)
{
unsigned int i, hsize, hshift, hlimit, entries, *hash_count;
const unsigned char *data;
struct index *entry, **hash;
unsigned int i, hsize, hshift, entries, *hash_count;
const unsigned char *data, *buffer = buf;
struct delta_index *index;
struct index_entry *entry, **hash;
void *mem;
if (!buf || !bufsize)
return NULL;
/* determine index hash size */
entries = bufsize / BLK_SIZE;
hsize = entries / 4;
for (i = 4; (1 << i) < hsize && i < 31; i++);
hsize = 1 << i;
hshift = 32 - i;
*hash_shift = hshift;
/* allocate lookup index */
mem = malloc(hsize * sizeof(*hash) + entries * sizeof(*entry));
mem = malloc(sizeof(*index) +
sizeof(*hash) * hsize +
sizeof(*entry) * entries);
if (!mem)
return NULL;
index = mem;
mem = index + 1;
hash = mem;
entry = mem + hsize * sizeof(*hash);
mem = hash + hsize;
entry = mem;
index->src_buf = buf;
index->src_size = bufsize;
index->hash_shift = hshift;
memset(hash, 0, hsize * sizeof(*hash));
/* allocate an array to count hash entries */
hash_count = calloc(hsize, sizeof(*hash_count));
if (!hash_count) {
free(hash);
free(index);
return NULL;
}
/* then populate the index */
data = buf + entries * BLK_SIZE - BLK_SIZE;
while (data >= buf) {
data = buffer + entries * BLK_SIZE - BLK_SIZE;
while (data >= buffer) {
unsigned int val = adler32(0, data, BLK_SIZE);
i = HASH(val, hshift);
entry->ptr = data;
@ -91,27 +108,18 @@ static struct index ** delta_index(const unsigned char *buf,
* bucket that would bring us to O(m*n) computing costs (m and n
* corresponding to reference and target buffer sizes).
*
* The more the target buffer is large, the more it is important to
* have small entry lists for each hash buckets. With such a limit
* the cost is bounded to something more like O(m+n).
*/
hlimit = (1 << 26) / trg_bufsize;
if (hlimit < 4*BLK_SIZE)
hlimit = 4*BLK_SIZE;
/*
* Now make sure none of the hash buckets has more entries than
* Make sure none of the hash buckets has more entries than
* we're willing to test. Otherwise we cull the entry list
* uniformly to still preserve a good repartition across
* the reference buffer.
*/
for (i = 0; i < hsize; i++) {
if (hash_count[i] < hlimit)
if (hash_count[i] < HASH_LIMIT)
continue;
entry = hash[i];
do {
struct index *keep = entry;
int skip = hash_count[i] / hlimit / 2;
struct index_entry *keep = entry;
int skip = hash_count[i] / HASH_LIMIT / 2;
do {
entry = entry->next;
} while(--skip && entry);
@ -120,7 +128,12 @@ static struct index ** delta_index(const unsigned char *buf,
}
free(hash_count);
return hash;
return index;
}
void free_delta_index(struct delta_index *index)
{
free(index);
}
/* provide the size of the copy opcode given the block offset and size */
@ -131,21 +144,17 @@ static struct index ** delta_index(const unsigned char *buf,
/* the maximum size for any opcode */
#define MAX_OP_SIZE COPYOP_SIZE(0xffffffff, 0xffffffff)
void *diff_delta(void *from_buf, unsigned long from_size,
void *to_buf, unsigned long to_size,
unsigned long *delta_size,
unsigned long max_size)
void *
create_delta(const struct delta_index *index,
const void *trg_buf, unsigned long trg_size,
unsigned long *delta_size, unsigned long max_size)
{
unsigned int i, outpos, outsize, hash_shift;
int inscnt;
const unsigned char *ref_data, *ref_top, *data, *top;
unsigned char *out;
struct index *entry, **hash;
if (!from_size || !to_size)
return NULL;
hash = delta_index(from_buf, from_size, to_size, &hash_shift);
if (!hash)
if (!trg_buf || !trg_size)
return NULL;
outpos = 0;
@ -153,60 +162,55 @@ void *diff_delta(void *from_buf, unsigned long from_size,
if (max_size && outsize >= max_size)
outsize = max_size + MAX_OP_SIZE + 1;
out = malloc(outsize);
if (!out) {
free(hash);
if (!out)
return NULL;
}
ref_data = from_buf;
ref_top = from_buf + from_size;
data = to_buf;
top = to_buf + to_size;
/* store reference buffer size */
out[outpos++] = from_size;
from_size >>= 7;
while (from_size) {
out[outpos - 1] |= 0x80;
out[outpos++] = from_size;
from_size >>= 7;
i = index->src_size;
while (i >= 0x80) {
out[outpos++] = i | 0x80;
i >>= 7;
}
out[outpos++] = i;
/* store target buffer size */
out[outpos++] = to_size;
to_size >>= 7;
while (to_size) {
out[outpos - 1] |= 0x80;
out[outpos++] = to_size;
to_size >>= 7;
i = trg_size;
while (i >= 0x80) {
out[outpos++] = i | 0x80;
i >>= 7;
}
out[outpos++] = i;
ref_data = index->src_buf;
ref_top = ref_data + index->src_size;
data = trg_buf;
top = trg_buf + trg_size;
hash_shift = index->hash_shift;
inscnt = 0;
while (data < top) {
unsigned int moff = 0, msize = 0;
if (data + BLK_SIZE <= top) {
unsigned int val = adler32(0, data, BLK_SIZE);
i = HASH(val, hash_shift);
for (entry = hash[i]; entry; entry = entry->next) {
const unsigned char *ref = entry->ptr;
const unsigned char *src = data;
unsigned int ref_size = ref_top - ref;
if (entry->val != val)
continue;
if (ref_size > top - src)
ref_size = top - src;
if (ref_size > 0x10000)
ref_size = 0x10000;
if (ref_size <= msize)
break;
while (ref_size-- && *src++ == *ref)
ref++;
if (msize < ref - entry->ptr) {
/* this is our best match so far */
msize = ref - entry->ptr;
moff = entry->ptr - ref_data;
}
struct index_entry *entry;
unsigned int val = adler32(0, data, BLK_SIZE);
i = HASH(val, hash_shift);
for (entry = index->hash[i]; entry; entry = entry->next) {
const unsigned char *ref = entry->ptr;
const unsigned char *src = data;
unsigned int ref_size = ref_top - ref;
if (entry->val != val)
continue;
if (ref_size > top - src)
ref_size = top - src;
if (ref_size > 0x10000)
ref_size = 0x10000;
if (ref_size <= msize)
break;
while (ref_size-- && *src++ == *ref)
ref++;
if (msize < ref - entry->ptr) {
/* this is our best match so far */
msize = ref - entry->ptr;
moff = entry->ptr - ref_data;
}
}
@ -271,7 +275,6 @@ void *diff_delta(void *from_buf, unsigned long from_size,
out = realloc(out, outsize);
if (!out) {
free(tmp);
free(hash);
return NULL;
}
}
@ -280,7 +283,6 @@ void *diff_delta(void *from_buf, unsigned long from_size,
if (inscnt)
out[outpos - inscnt - 1] = inscnt;
free(hash);
*delta_size = outpos;
return out;
}

4
patch-delta.c
View File

@ -13,8 +13,8 @@
#include <string.h>
#include "delta.h"
void *patch_delta(void *src_buf, unsigned long src_size,
void *delta_buf, unsigned long delta_size,
void *patch_delta(const void *src_buf, unsigned long src_size,
const void *delta_buf, unsigned long delta_size,
unsigned long *dst_size)
{
const unsigned char *data, *top;

12
rev-parse.c
View File

@ -160,6 +160,14 @@ static int show_file(const char *arg)
return 0;
}
static void die_badfile(const char *arg)
{
if (errno != ENOENT)
die("'%s': %s", arg, strerror(errno));
die("'%s' is ambiguous - revision name or file/directory name?\n"
"Please put '--' before the list of filenames.", arg);
}
int main(int argc, char **argv)
{
int i, as_is = 0, verify = 0;
@ -176,7 +184,7 @@ int main(int argc, char **argv)
if (as_is) {
if (show_file(arg) && as_is < 2)
if (lstat(arg, &st) < 0)
die("'%s': %s", arg, strerror(errno));
die_badfile(arg);
continue;
}
if (!strcmp(arg,"-n")) {
@ -343,7 +351,7 @@ int main(int argc, char **argv)
if (verify)
die("Needed a single revision");
if (lstat(arg, &st) < 0)
die("'%s': %s", arg, strerror(errno));
die_badfile(arg);
}
show_default();
if (verify && revs_count != 1)