apply.h

   1 #ifndef APPLY_H
   2 #define APPLY_H
   3
   4 #include "hash.h"
   5 #include "lockfile.h"
   6 #include "string-list.h"
   7
   8 struct repository;
   9
  10 enum apply_ws_error_action {
  11         nowarn_ws_error,
  12         warn_on_ws_error,
  13         die_on_ws_error,
  14         correct_ws_error
  15 };
  16
  17 enum apply_ws_ignore {
  18         ignore_ws_none,
  19         ignore_ws_change
  20 };
  21
  22 enum apply_verbosity {
  23         verbosity_silent = -1,
  24         verbosity_normal = 0,
  25         verbosity_verbose = 1
  26 };
  27
  28 /*
  29  * We need to keep track of how symlinks in the preimage are
  30  * manipulated by the patches.  A patch to add a/b/c where a/b
  31  * is a symlink should not be allowed to affect the directory
  32  * the symlink points at, but if the same patch removes a/b,
  33  * it is perfectly fine, as the patch removes a/b to make room
  34  * to create a directory a/b so that a/b/c can be created.
  35  *
  36  * See also "struct string_list symlink_changes" in "struct
  37  * apply_state".
  38  */
  39 #define APPLY_SYMLINK_GOES_AWAY 01
  40 #define APPLY_SYMLINK_IN_RESULT 02
  41
  42 struct apply_state {
  43         const char *prefix;
  44
  45         /* Lock file */
  46         struct lock_file lock_file;
  47
  48         /* These control what gets looked at and modified */
  49         int apply; /* this is not a dry-run */
  50         int cached; /* apply to the index only */
  51         int check; /* preimage must match working tree, don't actually apply */
  52         int check_index; /* preimage must match the indexed version */
  53         int update_index; /* check_index && apply */
  54         int ita_only;     /* add intent-to-add entries to the index */
  55
  56         /* These control cosmetic aspect of the output */
  57         int diffstat; /* just show a diffstat, and don't actually apply */
  58         int numstat; /* just show a numeric diffstat, and don't actually apply */
  59         int summary; /* just report creation, deletion, etc, and don't actually apply */
  60
  61         /* These boolean parameters control how the apply is done */
  62         int allow_overlap;
  63         int apply_in_reverse;
  64         int apply_with_reject;
  65         int no_add;
  66         int threeway;
  67         int unidiff_zero;
  68         int unsafe_paths;
  69         int allow_empty;
  70
  71         /* Other non boolean parameters */
  72         struct repository *repo;
  73         const char *index_file;
  74         enum apply_verbosity apply_verbosity;
  75         const char *fake_ancestor;
  76         const char *patch_input_file;
  77         int line_termination;
  78         struct strbuf root;
  79         int p_value;
  80         int p_value_known;
  81         unsigned int p_context;
  82
  83         /* Exclude and include path parameters */
  84         struct string_list limit_by_name;
  85         int has_include;
  86
  87         /* Various "current state" */
  88         int linenr; /* current line number */
  89         struct string_list symlink_changes; /* we have to track symlinks */
  90
  91         /*
  92          * For "diff-stat" like behaviour, we keep track of the biggest change
  93          * we've seen, and the longest filename. That allows us to do simple
  94          * scaling.
  95          */
  96         int max_change;
  97         int max_len;
  98
  99         /*
 100          * Records filenames that have been touched, in order to handle
 101          * the case where more than one patches touch the same file.
 102          */
 103         struct string_list fn_table;
 104
 105         /*
 106          * This is to save reporting routines before using
 107          * set_error_routine() or set_warn_routine() to install muting
 108          * routines when in verbosity_silent mode.
 109          */
 110         void (*saved_error_routine)(const char *err, va_list params);
 111         void (*saved_warn_routine)(const char *warn, va_list params);
 112
 113         /* These control whitespace errors */
 114         enum apply_ws_error_action ws_error_action;
 115         enum apply_ws_ignore ws_ignore_action;
 116         const char *whitespace_option;
 117         int whitespace_error;
 118         int squelch_whitespace_errors;
 119         int applied_after_fixing_ws;
 120 };
 121
 122 /*
 123  * This represents a "patch" to a file, both metainfo changes
 124  * such as creation/deletion, filemode and content changes represented
 125  * as a series of fragments.
 126  */
 127 struct patch {
 128         char *new_name, *old_name, *def_name;
 129         unsigned int old_mode, new_mode;
 130         int is_new, is_delete;  /* -1 = unknown, 0 = false, 1 = true */
 131         int rejected;
 132         unsigned ws_rule;
 133         int lines_added, lines_deleted;
 134         int score;
 135         int extension_linenr; /* first line specifying delete/new/rename/copy */
 136         unsigned int is_toplevel_relative:1;
 137         unsigned int inaccurate_eof:1;
 138         unsigned int is_binary:1;
 139         unsigned int is_copy:1;
 140         unsigned int is_rename:1;
 141         unsigned int recount:1;
 142         unsigned int conflicted_threeway:1;
 143         unsigned int direct_to_threeway:1;
 144         unsigned int crlf_in_old:1;
 145         struct fragment *fragments;
 146         char *result;
 147         size_t resultsize;
 148         char old_oid_prefix[GIT_MAX_HEXSZ + 1];
 149         char new_oid_prefix[GIT_MAX_HEXSZ + 1];
 150         struct patch *next;
 151
 152         /* three-way fallback result */
 153         struct object_id threeway_stage[3];
 154 };
 155
 156 int apply_parse_options(int argc, const char **argv,
 157                         struct apply_state *state,
 158                         int *force_apply, int *options,
 159                         const char * const *apply_usage);
 160 int init_apply_state(struct apply_state *state,
 161                      struct repository *repo,
 162                      const char *prefix);
 163 void clear_apply_state(struct apply_state *state);
 164 int check_apply_state(struct apply_state *state, int force_apply);
 165
 166 /*
 167  * Parse a git diff header, starting at line.  Fills the relevant
 168  * metadata information in 'struct patch'.
 169  *
 170  * Returns -1 on failure, the length of the parsed header otherwise.
 171  */
 172 int parse_git_diff_header(struct strbuf *root,
 173                           int *linenr,
 174                           int p_value,
 175                           const char *line,
 176                           int len,
 177                           unsigned int size,
 178                           struct patch *patch);
 179
 180 /*
 181  * Some aspects of the apply behavior are controlled by the following
 182  * bits in the "options" parameter passed to apply_all_patches().
 183  */
 184 #define APPLY_OPT_INACCURATE_EOF        (1<<0) /* accept inaccurate eof */
 185 #define APPLY_OPT_RECOUNT               (1<<1) /* accept inaccurate line count */
 186
 187 int apply_all_patches(struct apply_state *state,
 188                       int argc, const char **argv,
 189                       int options);
 190
 191 #endif