#include "rerere.h"
#include "apply.h"
+struct gitdiff_data {
+ struct strbuf *root;
+ int linenr;
+ int p_value;
+};
+
static void git_apply_config(void)
{
git_config_get_string_const("apply.whitespace", &apply_default_whitespace);
state->ws_error_action = correct_ws_error;
return 0;
}
+ /*
+ * Please update $__git_whitespacelist in git-completion.bash
+ * when you add new options.
+ */
return error(_("unrecognized whitespace option '%s'"), option);
}
#define BINARY_DELTA_DEFLATED 1
#define BINARY_LITERAL_DEFLATED 2
-/*
- * This represents a "patch" to a file, both metainfo changes
- * such as creation/deletion, filemode and content changes represented
- * as a series of fragments.
- */
-struct patch {
- char *new_name, *old_name, *def_name;
- unsigned int old_mode, new_mode;
- int is_new, is_delete; /* -1 = unknown, 0 = false, 1 = true */
- int rejected;
- unsigned ws_rule;
- int lines_added, lines_deleted;
- int score;
- int extension_linenr; /* first line specifying delete/new/rename/copy */
- unsigned int is_toplevel_relative:1;
- unsigned int inaccurate_eof:1;
- unsigned int is_binary:1;
- unsigned int is_copy:1;
- unsigned int is_rename:1;
- unsigned int recount:1;
- unsigned int conflicted_threeway:1;
- unsigned int direct_to_threeway:1;
- unsigned int crlf_in_old:1;
- struct fragment *fragments;
- char *result;
- size_t resultsize;
- char old_sha1_prefix[41];
- char new_sha1_prefix[41];
- struct patch *next;
-
- /* three-way fallback result */
- struct object_id threeway_stage[3];
-};
-
static void free_fragment_list(struct fragment *list)
{
while (list) {
return name;
}
-static char *find_name_gnu(struct apply_state *state,
+static char *find_name_gnu(struct strbuf *root,
const char *line,
- const char *def,
int p_value)
{
struct strbuf name = STRBUF_INIT;
/*
* Proposed "new-style" GNU patch/diff format; see
- * http://marc.info/?l=git&m=112927316408690&w=2
+ * https://public-inbox.org/git/7vll0wvb2a.fsf@assigned-by-dhcp.cox.net/
*/
if (unquote_c_style(&name, line, NULL)) {
strbuf_release(&name);
}
strbuf_remove(&name, 0, cp - name.buf);
- if (state->root.len)
- strbuf_insert(&name, 0, state->root.buf, state->root.len);
+ if (root->len)
+ strbuf_insert(&name, 0, root->buf, root->len);
return squash_slash(strbuf_detach(&name, NULL));
}
return line + len - end;
}
-static char *find_name_common(struct apply_state *state,
+static char *find_name_common(struct strbuf *root,
const char *line,
const char *def,
int p_value,
return squash_slash(xstrdup(def));
}
- if (state->root.len) {
- char *ret = xstrfmt("%s%.*s", state->root.buf, len, start);
+ if (root->len) {
+ char *ret = xstrfmt("%s%.*s", root->buf, len, start);
return squash_slash(ret);
}
return squash_slash(xmemdupz(start, len));
}
-static char *find_name(struct apply_state *state,
+static char *find_name(struct strbuf *root,
const char *line,
char *def,
int p_value,
int terminate)
{
if (*line == '"') {
- char *name = find_name_gnu(state, line, def, p_value);
+ char *name = find_name_gnu(root, line, p_value);
if (name)
return name;
}
- return find_name_common(state, line, def, p_value, NULL, terminate);
+ return find_name_common(root, line, def, p_value, NULL, terminate);
}
-static char *find_name_traditional(struct apply_state *state,
+static char *find_name_traditional(struct strbuf *root,
const char *line,
char *def,
int p_value)
size_t date_len;
if (*line == '"') {
- char *name = find_name_gnu(state, line, def, p_value);
+ char *name = find_name_gnu(root, line, p_value);
if (name)
return name;
}
len = strchrnul(line, '\n') - line;
date_len = diff_timestamp_len(line, len);
if (!date_len)
- return find_name_common(state, line, def, p_value, NULL, TERM_TAB);
+ return find_name_common(root, line, def, p_value, NULL, TERM_TAB);
len -= date_len;
- return find_name_common(state, line, def, p_value, line + len, 0);
+ return find_name_common(root, line, def, p_value, line + len, 0);
}
/*
if (is_dev_null(nameline))
return -1;
- name = find_name_traditional(state, nameline, NULL, 0);
+ name = find_name_traditional(&state->root, nameline, NULL, 0);
if (!name)
return -1;
cp = strchr(name, '/');
if (is_dev_null(first)) {
patch->is_new = 1;
patch->is_delete = 0;
- name = find_name_traditional(state, second, NULL, state->p_value);
+ name = find_name_traditional(&state->root, second, NULL, state->p_value);
patch->new_name = name;
} else if (is_dev_null(second)) {
patch->is_new = 0;
patch->is_delete = 1;
- name = find_name_traditional(state, first, NULL, state->p_value);
+ name = find_name_traditional(&state->root, first, NULL, state->p_value);
patch->old_name = name;
} else {
char *first_name;
- first_name = find_name_traditional(state, first, NULL, state->p_value);
- name = find_name_traditional(state, second, first_name, state->p_value);
+ first_name = find_name_traditional(&state->root, first, NULL, state->p_value);
+ name = find_name_traditional(&state->root, second, first_name, state->p_value);
free(first_name);
if (has_epoch_timestamp(first)) {
patch->is_new = 1;
return 0;
}
-static int gitdiff_hdrend(struct apply_state *state,
+static int gitdiff_hdrend(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
#define DIFF_OLD_NAME 0
#define DIFF_NEW_NAME 1
-static int gitdiff_verify_name(struct apply_state *state,
+static int gitdiff_verify_name(struct gitdiff_data *state,
const char *line,
int isnull,
char **name,
int side)
{
if (!*name && !isnull) {
- *name = find_name(state, line, NULL, state->p_value, TERM_TAB);
+ *name = find_name(state->root, line, NULL, state->p_value, TERM_TAB);
return 0;
}
if (isnull)
return error(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"),
*name, state->linenr);
- another = find_name(state, line, NULL, state->p_value, TERM_TAB);
+ another = find_name(state->root, line, NULL, state->p_value, TERM_TAB);
if (!another || strcmp(another, *name)) {
free(another);
return error((side == DIFF_NEW_NAME) ?
return 0;
}
-static int gitdiff_oldname(struct apply_state *state,
+static int gitdiff_oldname(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
DIFF_OLD_NAME);
}
-static int gitdiff_newname(struct apply_state *state,
+static int gitdiff_newname(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
return 0;
}
-static int gitdiff_oldmode(struct apply_state *state,
+static int gitdiff_oldmode(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
return parse_mode_line(line, state->linenr, &patch->old_mode);
}
-static int gitdiff_newmode(struct apply_state *state,
+static int gitdiff_newmode(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
return parse_mode_line(line, state->linenr, &patch->new_mode);
}
-static int gitdiff_delete(struct apply_state *state,
+static int gitdiff_delete(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
return gitdiff_oldmode(state, line, patch);
}
-static int gitdiff_newfile(struct apply_state *state,
+static int gitdiff_newfile(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
return gitdiff_newmode(state, line, patch);
}
-static int gitdiff_copysrc(struct apply_state *state,
+static int gitdiff_copysrc(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
patch->is_copy = 1;
free(patch->old_name);
- patch->old_name = find_name(state, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
+ patch->old_name = find_name(state->root, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
return 0;
}
-static int gitdiff_copydst(struct apply_state *state,
+static int gitdiff_copydst(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
patch->is_copy = 1;
free(patch->new_name);
- patch->new_name = find_name(state, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
+ patch->new_name = find_name(state->root, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
return 0;
}
-static int gitdiff_renamesrc(struct apply_state *state,
+static int gitdiff_renamesrc(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
patch->is_rename = 1;
free(patch->old_name);
- patch->old_name = find_name(state, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
+ patch->old_name = find_name(state->root, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
return 0;
}
-static int gitdiff_renamedst(struct apply_state *state,
+static int gitdiff_renamedst(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
patch->is_rename = 1;
free(patch->new_name);
- patch->new_name = find_name(state, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
+ patch->new_name = find_name(state->root, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);
return 0;
}
-static int gitdiff_similarity(struct apply_state *state,
+static int gitdiff_similarity(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
return 0;
}
-static int gitdiff_dissimilarity(struct apply_state *state,
+static int gitdiff_dissimilarity(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
return 0;
}
-static int gitdiff_index(struct apply_state *state,
+static int gitdiff_index(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
*/
const char *ptr, *eol;
int len;
+ const unsigned hexsz = the_hash_algo->hexsz;
ptr = strchr(line, '.');
- if (!ptr || ptr[1] != '.' || 40 < ptr - line)
+ if (!ptr || ptr[1] != '.' || hexsz < ptr - line)
return 0;
len = ptr - line;
- memcpy(patch->old_sha1_prefix, line, len);
- patch->old_sha1_prefix[len] = 0;
+ memcpy(patch->old_oid_prefix, line, len);
+ patch->old_oid_prefix[len] = 0;
line = ptr + 2;
ptr = strchr(line, ' ');
ptr = eol;
len = ptr - line;
- if (40 < len)
+ if (hexsz < len)
return 0;
- memcpy(patch->new_sha1_prefix, line, len);
- patch->new_sha1_prefix[len] = 0;
+ memcpy(patch->new_oid_prefix, line, len);
+ patch->new_oid_prefix[len] = 0;
if (*ptr == ' ')
return gitdiff_oldmode(state, ptr + 1, patch);
return 0;
* This is normal for a diff that doesn't change anything: we'll fall through
* into the next diff. Tell the parser to break out.
*/
-static int gitdiff_unrecognized(struct apply_state *state,
+static int gitdiff_unrecognized(struct gitdiff_data *state,
const char *line,
struct patch *patch)
{
* Skip p_value leading components from "line"; as we do not accept
* absolute paths, return NULL in that case.
*/
-static const char *skip_tree_prefix(struct apply_state *state,
+static const char *skip_tree_prefix(int p_value,
const char *line,
int llen)
{
int nslash;
int i;
- if (!state->p_value)
+ if (!p_value)
return (llen && line[0] == '/') ? NULL : line;
- nslash = state->p_value;
+ nslash = p_value;
for (i = 0; i < llen; i++) {
int ch = line[i];
if (ch == '/' && --nslash <= 0)
* creation or deletion of an empty file. In any of these cases,
* both sides are the same name under a/ and b/ respectively.
*/
-static char *git_header_name(struct apply_state *state,
+static char *git_header_name(int p_value,
const char *line,
int llen)
{
goto free_and_fail1;
/* strip the a/b prefix including trailing slash */
- cp = skip_tree_prefix(state, first.buf, first.len);
+ cp = skip_tree_prefix(p_value, first.buf, first.len);
if (!cp)
goto free_and_fail1;
strbuf_remove(&first, 0, cp - first.buf);
if (*second == '"') {
if (unquote_c_style(&sp, second, NULL))
goto free_and_fail1;
- cp = skip_tree_prefix(state, sp.buf, sp.len);
+ cp = skip_tree_prefix(p_value, sp.buf, sp.len);
if (!cp)
goto free_and_fail1;
/* They must match, otherwise ignore */
}
/* unquoted second */
- cp = skip_tree_prefix(state, second, line + llen - second);
+ cp = skip_tree_prefix(p_value, second, line + llen - second);
if (!cp)
goto free_and_fail1;
if (line + llen - cp != first.len ||
}
/* unquoted first name */
- name = skip_tree_prefix(state, line, llen);
+ name = skip_tree_prefix(p_value, line, llen);
if (!name)
return NULL;
if (unquote_c_style(&sp, second, NULL))
goto free_and_fail2;
- np = skip_tree_prefix(state, sp.buf, sp.len);
+ np = skip_tree_prefix(p_value, sp.buf, sp.len);
if (!np)
goto free_and_fail2;
*/
if (!name[len + 1])
return NULL; /* no postimage name */
- second = skip_tree_prefix(state, name + len + 1,
+ second = skip_tree_prefix(p_value, name + len + 1,
line_len - (len + 1));
if (!second)
return NULL;
}
}
-static int check_header_line(struct apply_state *state, struct patch *patch)
+static int check_header_line(int linenr, struct patch *patch)
{
int extensions = (patch->is_delete == 1) + (patch->is_new == 1) +
(patch->is_rename == 1) + (patch->is_copy == 1);
if (extensions > 1)
return error(_("inconsistent header lines %d and %d"),
- patch->extension_linenr, state->linenr);
+ patch->extension_linenr, linenr);
if (extensions && !patch->extension_linenr)
- patch->extension_linenr = state->linenr;
+ patch->extension_linenr = linenr;
return 0;
}
-/* Verify that we recognize the lines following a git header */
-static int parse_git_header(struct apply_state *state,
- const char *line,
- int len,
- unsigned int size,
- struct patch *patch)
+int parse_git_diff_header(struct strbuf *root,
+ int *linenr,
+ int p_value,
+ const char *line,
+ int len,
+ unsigned int size,
+ struct patch *patch)
{
unsigned long offset;
+ struct gitdiff_data parse_hdr_state;
/* A git diff has explicit new/delete information, so we don't guess */
patch->is_new = 0;
* or removing or adding empty files), so we get
* the default name from the header.
*/
- patch->def_name = git_header_name(state, line, len);
- if (patch->def_name && state->root.len) {
- char *s = xstrfmt("%s%s", state->root.buf, patch->def_name);
+ patch->def_name = git_header_name(p_value, line, len);
+ if (patch->def_name && root->len) {
+ char *s = xstrfmt("%s%s", root->buf, patch->def_name);
free(patch->def_name);
patch->def_name = s;
}
line += len;
size -= len;
- state->linenr++;
- for (offset = len ; size > 0 ; offset += len, size -= len, line += len, state->linenr++) {
+ (*linenr)++;
+ parse_hdr_state.root = root;
+ parse_hdr_state.linenr = *linenr;
+ parse_hdr_state.p_value = p_value;
+
+ for (offset = len ; size > 0 ; offset += len, size -= len, line += len, (*linenr)++) {
static const struct opentry {
const char *str;
- int (*fn)(struct apply_state *, const char *, struct patch *);
+ int (*fn)(struct gitdiff_data *, const char *, struct patch *);
} optable[] = {
{ "@@ -", gitdiff_hdrend },
{ "--- ", gitdiff_oldname },
int res;
if (len < oplen || memcmp(p->str, line, oplen))
continue;
- res = p->fn(state, line + oplen, patch);
+ res = p->fn(&parse_hdr_state, line + oplen, patch);
if (res < 0)
return -1;
- if (check_header_line(state, patch))
+ if (check_header_line(*linenr, patch))
return -1;
if (res > 0)
return offset;
* or mode change, so we handle that specially
*/
if (!memcmp("diff --git ", line, 11)) {
- int git_hdr_len = parse_git_header(state, line, len, size, patch);
+ int git_hdr_len = parse_git_diff_header(&state->root, &state->linenr,
+ state->p_value, line, len,
+ size, patch);
if (git_hdr_len < 0)
return -128;
if (git_hdr_len <= len)
}
if (oldlines || newlines)
return -1;
- if (!deleted && !added)
+ if (!patch->recount && !deleted && !added)
return -1;
fragment->leading = leading;
if (!use_patch(state, patch))
patch->ws_rule = 0;
+ else if (patch->new_name)
+ patch->ws_rule = whitespace_rule(state->repo->index,
+ patch->new_name);
else
- patch->ws_rule = whitespace_rule(patch->new_name
- ? patch->new_name
- : patch->old_name);
+ patch->ws_rule = whitespace_rule(state->repo->index,
+ patch->old_name);
patchsize = parse_single_patch(state,
buffer + offset + hdrsize,
SWAP(p->new_mode, p->old_mode);
SWAP(p->is_new, p->is_delete);
SWAP(p->lines_added, p->lines_deleted);
- SWAP(p->old_sha1_prefix, p->new_sha1_prefix);
+ SWAP(p->old_oid_prefix, p->new_oid_prefix);
for (; frag; frag = frag->next) {
SWAP(frag->newpos, frag->oldpos);
{
const char *name = patch->old_name ? patch->old_name : patch->new_name;
struct object_id oid;
+ const unsigned hexsz = the_hash_algo->hexsz;
/*
* For safety, we require patch index line to contain
- * full 40-byte textual SHA1 for old and new, at least for now.
+ * full hex textual object ID for old and new, at least for now.
*/
- if (strlen(patch->old_sha1_prefix) != 40 ||
- strlen(patch->new_sha1_prefix) != 40 ||
- get_oid_hex(patch->old_sha1_prefix, &oid) ||
- get_oid_hex(patch->new_sha1_prefix, &oid))
+ if (strlen(patch->old_oid_prefix) != hexsz ||
+ strlen(patch->new_oid_prefix) != hexsz ||
+ get_oid_hex(patch->old_oid_prefix, &oid) ||
+ get_oid_hex(patch->new_oid_prefix, &oid))
return error(_("cannot apply binary patch to '%s' "
"without full index line"), name);
* applies to.
*/
hash_object_file(img->buf, img->len, blob_type, &oid);
- if (strcmp(oid_to_hex(&oid), patch->old_sha1_prefix))
+ if (strcmp(oid_to_hex(&oid), patch->old_oid_prefix))
return error(_("the patch applies to '%s' (%s), "
"which does not match the "
"current contents."),
"'%s' but it is not empty"), name);
}
- get_oid_hex(patch->new_sha1_prefix, &oid);
+ get_oid_hex(patch->new_oid_prefix, &oid);
if (is_null_oid(&oid)) {
clear_image(img);
return 0; /* deletion patch */
}
- if (has_sha1_file(oid.hash)) {
+ if (has_object_file(&oid)) {
/* We already have the postimage */
enum object_type type;
unsigned long size;
if (!result)
return error(_("the necessary postimage %s for "
"'%s' cannot be read"),
- patch->new_sha1_prefix, name);
+ patch->new_oid_prefix, name);
clear_image(img);
img->buf = result;
img->len = size;
/* verify that the result matches */
hash_object_file(img->buf, img->len, blob_type, &oid);
- if (strcmp(oid_to_hex(&oid), patch->new_sha1_prefix))
+ if (strcmp(oid_to_hex(&oid), patch->new_oid_prefix))
return error(_("binary patch to '%s' creates incorrect result (expecting %s, got %s)"),
- name, patch->new_sha1_prefix, oid_to_hex(&oid));
+ name, patch->new_oid_prefix, oid_to_hex(&oid));
}
return 0;
costate.refresh_cache = 1;
costate.istate = istate;
- if (checkout_entry(ce, &costate, NULL) || lstat(ce->name, st))
+ if (checkout_entry(ce, &costate, NULL, NULL) ||
+ lstat(ce->name, st))
return error(_("cannot checkout %s"), ce->name);
return 0;
}
return 0;
}
-static int three_way_merge(struct image *image,
+static int three_way_merge(struct apply_state *state,
+ struct image *image,
char *path,
const struct object_id *base,
const struct object_id *ours,
status = ll_merge(&result, path,
&base_file, "base",
&our_file, "ours",
- &their_file, "theirs", NULL);
+ &their_file, "theirs",
+ state->repo->index,
+ NULL);
free(base_file.ptr);
free(our_file.ptr);
free(their_file.ptr);
/* Preimage the patch was prepared for */
if (patch->is_new)
write_object_file("", 0, blob_type, &pre_oid);
- else if (get_oid(patch->old_sha1_prefix, &pre_oid) ||
+ else if (get_oid(patch->old_oid_prefix, &pre_oid) ||
read_blob_object(&buf, &pre_oid, patch->old_mode))
return error(_("repository lacks the necessary blob to fall back on 3-way merge."));
clear_image(&tmp_image);
/* in-core three-way merge between post and our using pre as base */
- status = three_way_merge(image, patch->new_name,
+ status = three_way_merge(state, image, patch->new_name,
&pre_oid, &our_oid, &post_oid);
if (status < 0) {
if (state->apply_verbosity > verbosity_silent)
return read_index_from(state->repo->index, state->index_file,
get_git_dir());
else
- return read_index(state->repo->index);
+ return repo_read_index(state->repo);
}
/* This function tries to read the object name from the current index */
starts_with(++preimage, heading) &&
/* does it record full SHA-1? */
!get_oid_hex(preimage + sizeof(heading) - 1, oid) &&
- preimage[sizeof(heading) + GIT_SHA1_HEXSZ - 1] == '\n' &&
+ preimage[sizeof(heading) + the_hash_algo->hexsz - 1] == '\n' &&
/* does the abbreviated name on the index line agree with it? */
- starts_with(preimage + sizeof(heading) - 1, p->old_sha1_prefix))
+ starts_with(preimage + sizeof(heading) - 1, p->old_oid_prefix))
return 0; /* it all looks fine */
/* we may have full object name on the index line */
- return get_oid_hex(p->old_sha1_prefix, oid);
+ return get_oid_hex(p->old_oid_prefix, oid);
}
/* Build an index that contains just the files needed for a 3way merge */
else
return error(_("sha1 information is lacking or "
"useless for submodule %s"), name);
- } else if (!get_oid_blob(patch->old_sha1_prefix, &oid)) {
+ } else if (!get_oid_blob(patch->old_oid_prefix, &oid)) {
; /* ok */
} else if (!patch->lines_added && !patch->lines_deleted) {
/* mode-only change: update the current */
"created file '%s'"),
path);
}
- fill_stat_cache_info(ce, &st);
+ fill_stat_cache_info(state->repo->index, ce, &st);
}
if (write_object_file(buf, size, blob_type, &ce->oid) < 0) {
discard_cache_entry(ce);
}
string_list_clear(&cpath, 0);
- rerere(0);
+ repo_rerere(state->repo, 0);
}
return errs;
struct patch *list = NULL, **listp = &list;
int skipped_patch = 0;
int res = 0;
+ int flush_attributes = 0;
state->patch_input_file = filename;
if (read_patch_file(&buf, fd) < 0)
patch_stats(state, patch);
*listp = patch;
listp = &patch->next;
+
+ if ((patch->new_name &&
+ ends_with_path_components(patch->new_name,
+ GITATTRIBUTES_FILE)) ||
+ (patch->old_name &&
+ ends_with_path_components(patch->old_name,
+ GITATTRIBUTES_FILE)))
+ flush_attributes = 1;
}
else {
if (state->apply_verbosity > verbosity_normal)
state->index_file,
LOCK_DIE_ON_ERROR);
else
- hold_locked_index(&state->lock_file, LOCK_DIE_ON_ERROR);
+ repo_hold_locked_index(state->repo, &state->lock_file,
+ LOCK_DIE_ON_ERROR);
}
if (state->check_index && read_apply_cache(state) < 0) {
if (state->summary && state->apply_verbosity > verbosity_silent)
summary_patch_list(list);
+ if (flush_attributes)
+ reset_parsed_attributes();
end:
free_patch_list(list);
strbuf_release(&buf);
const char *arg, int unset)
{
struct apply_state *state = opt->value;
+
+ BUG_ON_OPT_NEG(unset);
+
add_name_limit(state, arg, 1);
return 0;
}
const char *arg, int unset)
{
struct apply_state *state = opt->value;
+
+ BUG_ON_OPT_NEG(unset);
+
add_name_limit(state, arg, 0);
state->has_include = 1;
return 0;
int unset)
{
struct apply_state *state = opt->value;
+
+ BUG_ON_OPT_NEG(unset);
+
state->p_value = atoi(arg);
state->p_value_known = 1;
return 0;
const char *arg, int unset)
{
struct apply_state *state = opt->value;
+
+ BUG_ON_OPT_ARG(arg);
+
if (unset)
state->ws_ignore_action = ignore_ws_none;
else
const char *arg, int unset)
{
struct apply_state *state = opt->value;
+
+ BUG_ON_OPT_NEG(unset);
+
state->whitespace_option = arg;
if (parse_whitespace_option(state, arg))
- exit(1);
+ return -1;
return 0;
}
const char *arg, int unset)
{
struct apply_state *state = opt->value;
+
+ BUG_ON_OPT_NEG(unset);
+
strbuf_reset(&state->root);
strbuf_addstr(&state->root, arg);
strbuf_complete(&state->root, '/');
struct option builtin_apply_options[] = {
{ OPTION_CALLBACK, 0, "exclude", state, N_("path"),
N_("don't apply changes matching the given path"),
- 0, apply_option_parse_exclude },
+ PARSE_OPT_NONEG, apply_option_parse_exclude },
{ OPTION_CALLBACK, 0, "include", state, N_("path"),
N_("apply changes matching the given path"),
- 0, apply_option_parse_include },
+ PARSE_OPT_NONEG, apply_option_parse_include },
{ OPTION_CALLBACK, 'p', NULL, state, N_("num"),
N_("remove <num> leading slashes from traditional diff paths"),
0, apply_option_parse_p },