1/* 2 * apply.c 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 * 6 * This applies patches on top of some (arbitrary) version of the SCM. 7 * 8 */ 9#include"cache.h" 10#include"cache-tree.h" 11#include"quote.h" 12#include"blob.h" 13#include"delta.h" 14#include"builtin.h" 15#include"string-list.h" 16#include"dir.h" 17#include"diff.h" 18#include"parse-options.h" 19#include"xdiff-interface.h" 20#include"ll-merge.h" 21#include"rerere.h" 22 23/* 24 * --check turns on checking that the working tree matches the 25 * files that are being modified, but doesn't apply the patch 26 * --stat does just a diffstat, and doesn't actually apply 27 * --numstat does numeric diffstat, and doesn't actually apply 28 * --index-info shows the old and new index info for paths if available. 29 * --index updates the cache as well. 30 * --cached updates only the cache without ever touching the working tree. 31 */ 32static const char*prefix; 33static int prefix_length = -1; 34static int newfd = -1; 35 36static int unidiff_zero; 37static int p_value =1; 38static int p_value_known; 39static int check_index; 40static int update_index; 41static int cached; 42static int diffstat; 43static int numstat; 44static int summary; 45static int check; 46static int apply =1; 47static int apply_in_reverse; 48static int apply_with_reject; 49static int apply_verbosely; 50static int allow_overlap; 51static int no_add; 52static int threeway; 53static const char*fake_ancestor; 54static int line_termination ='\n'; 55static unsigned int p_context = UINT_MAX; 56static const char*const apply_usage[] = { 57N_("git apply [options] [<patch>...]"), 58 NULL 59}; 60 61static enum ws_error_action { 62 nowarn_ws_error, 63 warn_on_ws_error, 64 die_on_ws_error, 65 correct_ws_error 66} ws_error_action = warn_on_ws_error; 67static int whitespace_error; 68static int squelch_whitespace_errors =5; 69static int applied_after_fixing_ws; 70 71static enum ws_ignore { 72 ignore_ws_none, 73 ignore_ws_change 74} ws_ignore_action = ignore_ws_none; 75 76 77static const char*patch_input_file; 78static const char*root; 79static int root_len; 80static int read_stdin =1; 81static int options; 82 83static voidparse_whitespace_option(const char*option) 84{ 85if(!option) { 86 ws_error_action = warn_on_ws_error; 87return; 88} 89if(!strcmp(option,"warn")) { 90 ws_error_action = warn_on_ws_error; 91return; 92} 93if(!strcmp(option,"nowarn")) { 94 ws_error_action = nowarn_ws_error; 95return; 96} 97if(!strcmp(option,"error")) { 98 ws_error_action = die_on_ws_error; 99return; 100} 101if(!strcmp(option,"error-all")) { 102 ws_error_action = die_on_ws_error; 103 squelch_whitespace_errors =0; 104return; 105} 106if(!strcmp(option,"strip") || !strcmp(option,"fix")) { 107 ws_error_action = correct_ws_error; 108return; 109} 110die(_("unrecognized whitespace option '%s'"), option); 111} 112 113static voidparse_ignorewhitespace_option(const char*option) 114{ 115if(!option || !strcmp(option,"no") || 116!strcmp(option,"false") || !strcmp(option,"never") || 117!strcmp(option,"none")) { 118 ws_ignore_action = ignore_ws_none; 119return; 120} 121if(!strcmp(option,"change")) { 122 ws_ignore_action = ignore_ws_change; 123return; 124} 125die(_("unrecognized whitespace ignore option '%s'"), option); 126} 127 128static voidset_default_whitespace_mode(const char*whitespace_option) 129{ 130if(!whitespace_option && !apply_default_whitespace) 131 ws_error_action = (apply ? warn_on_ws_error : nowarn_ws_error); 132} 133 134/* 135 * For "diff-stat" like behaviour, we keep track of the biggest change 136 * we've seen, and the longest filename. That allows us to do simple 137 * scaling. 138 */ 139static int max_change, max_len; 140 141/* 142 * Various "current state", notably line numbers and what 143 * file (and how) we're patching right now.. The "is_xxxx" 144 * things are flags, where -1 means "don't know yet". 145 */ 146static int linenr =1; 147 148/* 149 * This represents one "hunk" from a patch, starting with 150 * "@@ -oldpos,oldlines +newpos,newlines @@" marker. The 151 * patch text is pointed at by patch, and its byte length 152 * is stored in size. leading and trailing are the number 153 * of context lines. 154 */ 155struct fragment { 156unsigned long leading, trailing; 157unsigned long oldpos, oldlines; 158unsigned long newpos, newlines; 159/* 160 * 'patch' is usually borrowed from buf in apply_patch(), 161 * but some codepaths store an allocated buffer. 162 */ 163const char*patch; 164unsigned free_patch:1, 165 rejected:1; 166int size; 167int linenr; 168struct fragment *next; 169}; 170 171/* 172 * When dealing with a binary patch, we reuse "leading" field 173 * to store the type of the binary hunk, either deflated "delta" 174 * or deflated "literal". 175 */ 176#define binary_patch_method leading 177#define BINARY_DELTA_DEFLATED 1 178#define BINARY_LITERAL_DEFLATED 2 179 180/* 181 * This represents a "patch" to a file, both metainfo changes 182 * such as creation/deletion, filemode and content changes represented 183 * as a series of fragments. 184 */ 185struct patch { 186char*new_name, *old_name, *def_name; 187unsigned int old_mode, new_mode; 188int is_new, is_delete;/* -1 = unknown, 0 = false, 1 = true */ 189int rejected; 190unsigned ws_rule; 191int lines_added, lines_deleted; 192int score; 193unsigned int is_toplevel_relative:1; 194unsigned int inaccurate_eof:1; 195unsigned int is_binary:1; 196unsigned int is_copy:1; 197unsigned int is_rename:1; 198unsigned int recount:1; 199unsigned int conflicted_threeway:1; 200unsigned int direct_to_threeway:1; 201struct fragment *fragments; 202char*result; 203size_t resultsize; 204char old_sha1_prefix[41]; 205char new_sha1_prefix[41]; 206struct patch *next; 207 208/* three-way fallback result */ 209unsigned char threeway_stage[3][20]; 210}; 211 212static voidfree_fragment_list(struct fragment *list) 213{ 214while(list) { 215struct fragment *next = list->next; 216if(list->free_patch) 217free((char*)list->patch); 218free(list); 219 list = next; 220} 221} 222 223static voidfree_patch(struct patch *patch) 224{ 225free_fragment_list(patch->fragments); 226free(patch->def_name); 227free(patch->old_name); 228free(patch->new_name); 229free(patch->result); 230free(patch); 231} 232 233static voidfree_patch_list(struct patch *list) 234{ 235while(list) { 236struct patch *next = list->next; 237free_patch(list); 238 list = next; 239} 240} 241 242/* 243 * A line in a file, len-bytes long (includes the terminating LF, 244 * except for an incomplete line at the end if the file ends with 245 * one), and its contents hashes to 'hash'. 246 */ 247struct line { 248size_t len; 249unsigned hash :24; 250unsigned flag :8; 251#define LINE_COMMON 1 252#define LINE_PATCHED 2 253}; 254 255/* 256 * This represents a "file", which is an array of "lines". 257 */ 258struct image { 259char*buf; 260size_t len; 261size_t nr; 262size_t alloc; 263struct line *line_allocated; 264struct line *line; 265}; 266 267/* 268 * Records filenames that have been touched, in order to handle 269 * the case where more than one patches touch the same file. 270 */ 271 272static struct string_list fn_table; 273 274static uint32_thash_line(const char*cp,size_t len) 275{ 276size_t i; 277uint32_t h; 278for(i =0, h =0; i < len; i++) { 279if(!isspace(cp[i])) { 280 h = h *3+ (cp[i] &0xff); 281} 282} 283return h; 284} 285 286/* 287 * Compare lines s1 of length n1 and s2 of length n2, ignoring 288 * whitespace difference. Returns 1 if they match, 0 otherwise 289 */ 290static intfuzzy_matchlines(const char*s1,size_t n1, 291const char*s2,size_t n2) 292{ 293const char*last1 = s1 + n1 -1; 294const char*last2 = s2 + n2 -1; 295int result =0; 296 297/* ignore line endings */ 298while((*last1 =='\r') || (*last1 =='\n')) 299 last1--; 300while((*last2 =='\r') || (*last2 =='\n')) 301 last2--; 302 303/* skip leading whitespace */ 304while(isspace(*s1) && (s1 <= last1)) 305 s1++; 306while(isspace(*s2) && (s2 <= last2)) 307 s2++; 308/* early return if both lines are empty */ 309if((s1 > last1) && (s2 > last2)) 310return1; 311while(!result) { 312 result = *s1++ - *s2++; 313/* 314 * Skip whitespace inside. We check for whitespace on 315 * both buffers because we don't want "a b" to match 316 * "ab" 317 */ 318if(isspace(*s1) &&isspace(*s2)) { 319while(isspace(*s1) && s1 <= last1) 320 s1++; 321while(isspace(*s2) && s2 <= last2) 322 s2++; 323} 324/* 325 * If we reached the end on one side only, 326 * lines don't match 327 */ 328if( 329((s2 > last2) && (s1 <= last1)) || 330((s1 > last1) && (s2 <= last2))) 331return0; 332if((s1 > last1) && (s2 > last2)) 333break; 334} 335 336return!result; 337} 338 339static voidadd_line_info(struct image *img,const char*bol,size_t len,unsigned flag) 340{ 341ALLOC_GROW(img->line_allocated, img->nr +1, img->alloc); 342 img->line_allocated[img->nr].len = len; 343 img->line_allocated[img->nr].hash =hash_line(bol, len); 344 img->line_allocated[img->nr].flag = flag; 345 img->nr++; 346} 347 348/* 349 * "buf" has the file contents to be patched (read from various sources). 350 * attach it to "image" and add line-based index to it. 351 * "image" now owns the "buf". 352 */ 353static voidprepare_image(struct image *image,char*buf,size_t len, 354int prepare_linetable) 355{ 356const char*cp, *ep; 357 358memset(image,0,sizeof(*image)); 359 image->buf = buf; 360 image->len = len; 361 362if(!prepare_linetable) 363return; 364 365 ep = image->buf + image->len; 366 cp = image->buf; 367while(cp < ep) { 368const char*next; 369for(next = cp; next < ep && *next !='\n'; next++) 370; 371if(next < ep) 372 next++; 373add_line_info(image, cp, next - cp,0); 374 cp = next; 375} 376 image->line = image->line_allocated; 377} 378 379static voidclear_image(struct image *image) 380{ 381free(image->buf); 382free(image->line_allocated); 383memset(image,0,sizeof(*image)); 384} 385 386/* fmt must contain _one_ %s and no other substitution */ 387static voidsay_patch_name(FILE*output,const char*fmt,struct patch *patch) 388{ 389struct strbuf sb = STRBUF_INIT; 390 391if(patch->old_name && patch->new_name && 392strcmp(patch->old_name, patch->new_name)) { 393quote_c_style(patch->old_name, &sb, NULL,0); 394strbuf_addstr(&sb," => "); 395quote_c_style(patch->new_name, &sb, NULL,0); 396}else{ 397const char*n = patch->new_name; 398if(!n) 399 n = patch->old_name; 400quote_c_style(n, &sb, NULL,0); 401} 402fprintf(output, fmt, sb.buf); 403fputc('\n', output); 404strbuf_release(&sb); 405} 406 407#define SLOP (16) 408 409static voidread_patch_file(struct strbuf *sb,int fd) 410{ 411if(strbuf_read(sb, fd,0) <0) 412die_errno("git apply: failed to read"); 413 414/* 415 * Make sure that we have some slop in the buffer 416 * so that we can do speculative "memcmp" etc, and 417 * see to it that it is NUL-filled. 418 */ 419strbuf_grow(sb, SLOP); 420memset(sb->buf + sb->len,0, SLOP); 421} 422 423static unsigned longlinelen(const char*buffer,unsigned long size) 424{ 425unsigned long len =0; 426while(size--) { 427 len++; 428if(*buffer++ =='\n') 429break; 430} 431return len; 432} 433 434static intis_dev_null(const char*str) 435{ 436return!memcmp("/dev/null", str,9) &&isspace(str[9]); 437} 438 439#define TERM_SPACE 1 440#define TERM_TAB 2 441 442static intname_terminate(const char*name,int namelen,int c,int terminate) 443{ 444if(c ==' '&& !(terminate & TERM_SPACE)) 445return0; 446if(c =='\t'&& !(terminate & TERM_TAB)) 447return0; 448 449return1; 450} 451 452/* remove double slashes to make --index work with such filenames */ 453static char*squash_slash(char*name) 454{ 455int i =0, j =0; 456 457if(!name) 458return NULL; 459 460while(name[i]) { 461if((name[j++] = name[i++]) =='/') 462while(name[i] =='/') 463 i++; 464} 465 name[j] ='\0'; 466return name; 467} 468 469static char*find_name_gnu(const char*line,const char*def,int p_value) 470{ 471struct strbuf name = STRBUF_INIT; 472char*cp; 473 474/* 475 * Proposed "new-style" GNU patch/diff format; see 476 * http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2 477 */ 478if(unquote_c_style(&name, line, NULL)) { 479strbuf_release(&name); 480return NULL; 481} 482 483for(cp = name.buf; p_value; p_value--) { 484 cp =strchr(cp,'/'); 485if(!cp) { 486strbuf_release(&name); 487return NULL; 488} 489 cp++; 490} 491 492strbuf_remove(&name,0, cp - name.buf); 493if(root) 494strbuf_insert(&name,0, root, root_len); 495returnsquash_slash(strbuf_detach(&name, NULL)); 496} 497 498static size_tsane_tz_len(const char*line,size_t len) 499{ 500const char*tz, *p; 501 502if(len <strlen(" +0500") || line[len-strlen(" +0500")] !=' ') 503return0; 504 tz = line + len -strlen(" +0500"); 505 506if(tz[1] !='+'&& tz[1] !='-') 507return0; 508 509for(p = tz +2; p != line + len; p++) 510if(!isdigit(*p)) 511return0; 512 513return line + len - tz; 514} 515 516static size_ttz_with_colon_len(const char*line,size_t len) 517{ 518const char*tz, *p; 519 520if(len <strlen(" +08:00") || line[len -strlen(":00")] !=':') 521return0; 522 tz = line + len -strlen(" +08:00"); 523 524if(tz[0] !=' '|| (tz[1] !='+'&& tz[1] !='-')) 525return0; 526 p = tz +2; 527if(!isdigit(*p++) || !isdigit(*p++) || *p++ !=':'|| 528!isdigit(*p++) || !isdigit(*p++)) 529return0; 530 531return line + len - tz; 532} 533 534static size_tdate_len(const char*line,size_t len) 535{ 536const char*date, *p; 537 538if(len <strlen("72-02-05") || line[len-strlen("-05")] !='-') 539return0; 540 p = date = line + len -strlen("72-02-05"); 541 542if(!isdigit(*p++) || !isdigit(*p++) || *p++ !='-'|| 543!isdigit(*p++) || !isdigit(*p++) || *p++ !='-'|| 544!isdigit(*p++) || !isdigit(*p++))/* Not a date. */ 545return0; 546 547if(date - line >=strlen("19") && 548isdigit(date[-1]) &&isdigit(date[-2]))/* 4-digit year */ 549 date -=strlen("19"); 550 551return line + len - date; 552} 553 554static size_tshort_time_len(const char*line,size_t len) 555{ 556const char*time, *p; 557 558if(len <strlen(" 07:01:32") || line[len-strlen(":32")] !=':') 559return0; 560 p = time = line + len -strlen(" 07:01:32"); 561 562/* Permit 1-digit hours? */ 563if(*p++ !=' '|| 564!isdigit(*p++) || !isdigit(*p++) || *p++ !=':'|| 565!isdigit(*p++) || !isdigit(*p++) || *p++ !=':'|| 566!isdigit(*p++) || !isdigit(*p++))/* Not a time. */ 567return0; 568 569return line + len - time; 570} 571 572static size_tfractional_time_len(const char*line,size_t len) 573{ 574const char*p; 575size_t n; 576 577/* Expected format: 19:41:17.620000023 */ 578if(!len || !isdigit(line[len -1])) 579return0; 580 p = line + len -1; 581 582/* Fractional seconds. */ 583while(p > line &&isdigit(*p)) 584 p--; 585if(*p !='.') 586return0; 587 588/* Hours, minutes, and whole seconds. */ 589 n =short_time_len(line, p - line); 590if(!n) 591return0; 592 593return line + len - p + n; 594} 595 596static size_ttrailing_spaces_len(const char*line,size_t len) 597{ 598const char*p; 599 600/* Expected format: ' ' x (1 or more) */ 601if(!len || line[len -1] !=' ') 602return0; 603 604 p = line + len; 605while(p != line) { 606 p--; 607if(*p !=' ') 608return line + len - (p +1); 609} 610 611/* All spaces! */ 612return len; 613} 614 615static size_tdiff_timestamp_len(const char*line,size_t len) 616{ 617const char*end = line + len; 618size_t n; 619 620/* 621 * Posix: 2010-07-05 19:41:17 622 * GNU: 2010-07-05 19:41:17.620000023 -0500 623 */ 624 625if(!isdigit(end[-1])) 626return0; 627 628 n =sane_tz_len(line, end - line); 629if(!n) 630 n =tz_with_colon_len(line, end - line); 631 end -= n; 632 633 n =short_time_len(line, end - line); 634if(!n) 635 n =fractional_time_len(line, end - line); 636 end -= n; 637 638 n =date_len(line, end - line); 639if(!n)/* No date. Too bad. */ 640return0; 641 end -= n; 642 643if(end == line)/* No space before date. */ 644return0; 645if(end[-1] =='\t') {/* Success! */ 646 end--; 647return line + len - end; 648} 649if(end[-1] !=' ')/* No space before date. */ 650return0; 651 652/* Whitespace damage. */ 653 end -=trailing_spaces_len(line, end - line); 654return line + len - end; 655} 656 657static char*null_strdup(const char*s) 658{ 659return s ?xstrdup(s) : NULL; 660} 661 662static char*find_name_common(const char*line,const char*def, 663int p_value,const char*end,int terminate) 664{ 665int len; 666const char*start = NULL; 667 668if(p_value ==0) 669 start = line; 670while(line != end) { 671char c = *line; 672 673if(!end &&isspace(c)) { 674if(c =='\n') 675break; 676if(name_terminate(start, line-start, c, terminate)) 677break; 678} 679 line++; 680if(c =='/'&& !--p_value) 681 start = line; 682} 683if(!start) 684returnsquash_slash(null_strdup(def)); 685 len = line - start; 686if(!len) 687returnsquash_slash(null_strdup(def)); 688 689/* 690 * Generally we prefer the shorter name, especially 691 * if the other one is just a variation of that with 692 * something else tacked on to the end (ie "file.orig" 693 * or "file~"). 694 */ 695if(def) { 696int deflen =strlen(def); 697if(deflen < len && !strncmp(start, def, deflen)) 698returnsquash_slash(xstrdup(def)); 699} 700 701if(root) { 702char*ret =xmalloc(root_len + len +1); 703strcpy(ret, root); 704memcpy(ret + root_len, start, len); 705 ret[root_len + len] ='\0'; 706returnsquash_slash(ret); 707} 708 709returnsquash_slash(xmemdupz(start, len)); 710} 711 712static char*find_name(const char*line,char*def,int p_value,int terminate) 713{ 714if(*line =='"') { 715char*name =find_name_gnu(line, def, p_value); 716if(name) 717return name; 718} 719 720returnfind_name_common(line, def, p_value, NULL, terminate); 721} 722 723static char*find_name_traditional(const char*line,char*def,int p_value) 724{ 725size_t len =strlen(line); 726size_t date_len; 727 728if(*line =='"') { 729char*name =find_name_gnu(line, def, p_value); 730if(name) 731return name; 732} 733 734 len =strchrnul(line,'\n') - line; 735 date_len =diff_timestamp_len(line, len); 736if(!date_len) 737returnfind_name_common(line, def, p_value, NULL, TERM_TAB); 738 len -= date_len; 739 740returnfind_name_common(line, def, p_value, line + len,0); 741} 742 743static intcount_slashes(const char*cp) 744{ 745int cnt =0; 746char ch; 747 748while((ch = *cp++)) 749if(ch =='/') 750 cnt++; 751return cnt; 752} 753 754/* 755 * Given the string after "--- " or "+++ ", guess the appropriate 756 * p_value for the given patch. 757 */ 758static intguess_p_value(const char*nameline) 759{ 760char*name, *cp; 761int val = -1; 762 763if(is_dev_null(nameline)) 764return-1; 765 name =find_name_traditional(nameline, NULL,0); 766if(!name) 767return-1; 768 cp =strchr(name,'/'); 769if(!cp) 770 val =0; 771else if(prefix) { 772/* 773 * Does it begin with "a/$our-prefix" and such? Then this is 774 * very likely to apply to our directory. 775 */ 776if(!strncmp(name, prefix, prefix_length)) 777 val =count_slashes(prefix); 778else{ 779 cp++; 780if(!strncmp(cp, prefix, prefix_length)) 781 val =count_slashes(prefix) +1; 782} 783} 784free(name); 785return val; 786} 787 788/* 789 * Does the ---/+++ line has the POSIX timestamp after the last HT? 790 * GNU diff puts epoch there to signal a creation/deletion event. Is 791 * this such a timestamp? 792 */ 793static inthas_epoch_timestamp(const char*nameline) 794{ 795/* 796 * We are only interested in epoch timestamp; any non-zero 797 * fraction cannot be one, hence "(\.0+)?" in the regexp below. 798 * For the same reason, the date must be either 1969-12-31 or 799 * 1970-01-01, and the seconds part must be "00". 800 */ 801const char stamp_regexp[] = 802"^(1969-12-31|1970-01-01)" 803" " 804"[0-2][0-9]:[0-5][0-9]:00(\\.0+)?" 805" " 806"([-+][0-2][0-9]:?[0-5][0-9])\n"; 807const char*timestamp = NULL, *cp, *colon; 808static regex_t *stamp; 809 regmatch_t m[10]; 810int zoneoffset; 811int hourminute; 812int status; 813 814for(cp = nameline; *cp !='\n'; cp++) { 815if(*cp =='\t') 816 timestamp = cp +1; 817} 818if(!timestamp) 819return0; 820if(!stamp) { 821 stamp =xmalloc(sizeof(*stamp)); 822if(regcomp(stamp, stamp_regexp, REG_EXTENDED)) { 823warning(_("Cannot prepare timestamp regexp%s"), 824 stamp_regexp); 825return0; 826} 827} 828 829 status =regexec(stamp, timestamp,ARRAY_SIZE(m), m,0); 830if(status) { 831if(status != REG_NOMATCH) 832warning(_("regexec returned%dfor input:%s"), 833 status, timestamp); 834return0; 835} 836 837 zoneoffset =strtol(timestamp + m[3].rm_so +1, (char**) &colon,10); 838if(*colon ==':') 839 zoneoffset = zoneoffset *60+strtol(colon +1, NULL,10); 840else 841 zoneoffset = (zoneoffset /100) *60+ (zoneoffset %100); 842if(timestamp[m[3].rm_so] =='-') 843 zoneoffset = -zoneoffset; 844 845/* 846 * YYYY-MM-DD hh:mm:ss must be from either 1969-12-31 847 * (west of GMT) or 1970-01-01 (east of GMT) 848 */ 849if((zoneoffset <0&&memcmp(timestamp,"1969-12-31",10)) || 850(0<= zoneoffset &&memcmp(timestamp,"1970-01-01",10))) 851return0; 852 853 hourminute = (strtol(timestamp +11, NULL,10) *60+ 854strtol(timestamp +14, NULL,10) - 855 zoneoffset); 856 857return((zoneoffset <0&& hourminute ==1440) || 858(0<= zoneoffset && !hourminute)); 859} 860 861/* 862 * Get the name etc info from the ---/+++ lines of a traditional patch header 863 * 864 * FIXME! The end-of-filename heuristics are kind of screwy. For existing 865 * files, we can happily check the index for a match, but for creating a 866 * new file we should try to match whatever "patch" does. I have no idea. 867 */ 868static voidparse_traditional_patch(const char*first,const char*second,struct patch *patch) 869{ 870char*name; 871 872 first +=4;/* skip "--- " */ 873 second +=4;/* skip "+++ " */ 874if(!p_value_known) { 875int p, q; 876 p =guess_p_value(first); 877 q =guess_p_value(second); 878if(p <0) p = q; 879if(0<= p && p == q) { 880 p_value = p; 881 p_value_known =1; 882} 883} 884if(is_dev_null(first)) { 885 patch->is_new =1; 886 patch->is_delete =0; 887 name =find_name_traditional(second, NULL, p_value); 888 patch->new_name = name; 889}else if(is_dev_null(second)) { 890 patch->is_new =0; 891 patch->is_delete =1; 892 name =find_name_traditional(first, NULL, p_value); 893 patch->old_name = name; 894}else{ 895char*first_name; 896 first_name =find_name_traditional(first, NULL, p_value); 897 name =find_name_traditional(second, first_name, p_value); 898free(first_name); 899if(has_epoch_timestamp(first)) { 900 patch->is_new =1; 901 patch->is_delete =0; 902 patch->new_name = name; 903}else if(has_epoch_timestamp(second)) { 904 patch->is_new =0; 905 patch->is_delete =1; 906 patch->old_name = name; 907}else{ 908 patch->old_name = name; 909 patch->new_name =xstrdup(name); 910} 911} 912if(!name) 913die(_("unable to find filename in patch at line%d"), linenr); 914} 915 916static intgitdiff_hdrend(const char*line,struct patch *patch) 917{ 918return-1; 919} 920 921/* 922 * We're anal about diff header consistency, to make 923 * sure that we don't end up having strange ambiguous 924 * patches floating around. 925 * 926 * As a result, gitdiff_{old|new}name() will check 927 * their names against any previous information, just 928 * to make sure.. 929 */ 930#define DIFF_OLD_NAME 0 931#define DIFF_NEW_NAME 1 932 933static char*gitdiff_verify_name(const char*line,int isnull,char*orig_name,int side) 934{ 935if(!orig_name && !isnull) 936returnfind_name(line, NULL, p_value, TERM_TAB); 937 938if(orig_name) { 939int len; 940const char*name; 941char*another; 942 name = orig_name; 943 len =strlen(name); 944if(isnull) 945die(_("git apply: bad git-diff - expected /dev/null, got%son line%d"), name, linenr); 946 another =find_name(line, NULL, p_value, TERM_TAB); 947if(!another ||memcmp(another, name, len +1)) 948die((side == DIFF_NEW_NAME) ? 949_("git apply: bad git-diff - inconsistent new filename on line%d") : 950_("git apply: bad git-diff - inconsistent old filename on line%d"), linenr); 951free(another); 952return orig_name; 953} 954else{ 955/* expect "/dev/null" */ 956if(memcmp("/dev/null", line,9) || line[9] !='\n') 957die(_("git apply: bad git-diff - expected /dev/null on line%d"), linenr); 958return NULL; 959} 960} 961 962static intgitdiff_oldname(const char*line,struct patch *patch) 963{ 964char*orig = patch->old_name; 965 patch->old_name =gitdiff_verify_name(line, patch->is_new, patch->old_name, 966 DIFF_OLD_NAME); 967if(orig != patch->old_name) 968free(orig); 969return0; 970} 971 972static intgitdiff_newname(const char*line,struct patch *patch) 973{ 974char*orig = patch->new_name; 975 patch->new_name =gitdiff_verify_name(line, patch->is_delete, patch->new_name, 976 DIFF_NEW_NAME); 977if(orig != patch->new_name) 978free(orig); 979return0; 980} 981 982static intgitdiff_oldmode(const char*line,struct patch *patch) 983{ 984 patch->old_mode =strtoul(line, NULL,8); 985return0; 986} 987 988static intgitdiff_newmode(const char*line,struct patch *patch) 989{ 990 patch->new_mode =strtoul(line, NULL,8); 991return0; 992} 993 994static intgitdiff_delete(const char*line,struct patch *patch) 995{ 996 patch->is_delete =1; 997free(patch->old_name); 998 patch->old_name =null_strdup(patch->def_name); 999returngitdiff_oldmode(line, patch);1000}10011002static intgitdiff_newfile(const char*line,struct patch *patch)1003{1004 patch->is_new =1;1005free(patch->new_name);1006 patch->new_name =null_strdup(patch->def_name);1007returngitdiff_newmode(line, patch);1008}10091010static intgitdiff_copysrc(const char*line,struct patch *patch)1011{1012 patch->is_copy =1;1013free(patch->old_name);1014 patch->old_name =find_name(line, NULL, p_value ? p_value -1:0,0);1015return0;1016}10171018static intgitdiff_copydst(const char*line,struct patch *patch)1019{1020 patch->is_copy =1;1021free(patch->new_name);1022 patch->new_name =find_name(line, NULL, p_value ? p_value -1:0,0);1023return0;1024}10251026static intgitdiff_renamesrc(const char*line,struct patch *patch)1027{1028 patch->is_rename =1;1029free(patch->old_name);1030 patch->old_name =find_name(line, NULL, p_value ? p_value -1:0,0);1031return0;1032}10331034static intgitdiff_renamedst(const char*line,struct patch *patch)1035{1036 patch->is_rename =1;1037free(patch->new_name);1038 patch->new_name =find_name(line, NULL, p_value ? p_value -1:0,0);1039return0;1040}10411042static intgitdiff_similarity(const char*line,struct patch *patch)1043{1044if((patch->score =strtoul(line, NULL,10)) == ULONG_MAX)1045 patch->score =0;1046return0;1047}10481049static intgitdiff_dissimilarity(const char*line,struct patch *patch)1050{1051if((patch->score =strtoul(line, NULL,10)) == ULONG_MAX)1052 patch->score =0;1053return0;1054}10551056static intgitdiff_index(const char*line,struct patch *patch)1057{1058/*1059 * index line is N hexadecimal, "..", N hexadecimal,1060 * and optional space with octal mode.1061 */1062const char*ptr, *eol;1063int len;10641065 ptr =strchr(line,'.');1066if(!ptr || ptr[1] !='.'||40< ptr - line)1067return0;1068 len = ptr - line;1069memcpy(patch->old_sha1_prefix, line, len);1070 patch->old_sha1_prefix[len] =0;10711072 line = ptr +2;1073 ptr =strchr(line,' ');1074 eol =strchr(line,'\n');10751076if(!ptr || eol < ptr)1077 ptr = eol;1078 len = ptr - line;10791080if(40< len)1081return0;1082memcpy(patch->new_sha1_prefix, line, len);1083 patch->new_sha1_prefix[len] =0;1084if(*ptr ==' ')1085 patch->old_mode =strtoul(ptr+1, NULL,8);1086return0;1087}10881089/*1090 * This is normal for a diff that doesn't change anything: we'll fall through1091 * into the next diff. Tell the parser to break out.1092 */1093static intgitdiff_unrecognized(const char*line,struct patch *patch)1094{1095return-1;1096}10971098/*1099 * Skip p_value leading components from "line"; as we do not accept1100 * absolute paths, return NULL in that case.1101 */1102static const char*skip_tree_prefix(const char*line,int llen)1103{1104int nslash;1105int i;11061107if(!p_value)1108return(llen && line[0] =='/') ? NULL : line;11091110 nslash = p_value;1111for(i =0; i < llen; i++) {1112int ch = line[i];1113if(ch =='/'&& --nslash <=0)1114return(i ==0) ? NULL : &line[i +1];1115}1116return NULL;1117}11181119/*1120 * This is to extract the same name that appears on "diff --git"1121 * line. We do not find and return anything if it is a rename1122 * patch, and it is OK because we will find the name elsewhere.1123 * We need to reliably find name only when it is mode-change only,1124 * creation or deletion of an empty file. In any of these cases,1125 * both sides are the same name under a/ and b/ respectively.1126 */1127static char*git_header_name(const char*line,int llen)1128{1129const char*name;1130const char*second = NULL;1131size_t len, line_len;11321133 line +=strlen("diff --git ");1134 llen -=strlen("diff --git ");11351136if(*line =='"') {1137const char*cp;1138struct strbuf first = STRBUF_INIT;1139struct strbuf sp = STRBUF_INIT;11401141if(unquote_c_style(&first, line, &second))1142goto free_and_fail1;11431144/* strip the a/b prefix including trailing slash */1145 cp =skip_tree_prefix(first.buf, first.len);1146if(!cp)1147goto free_and_fail1;1148strbuf_remove(&first,0, cp - first.buf);11491150/*1151 * second points at one past closing dq of name.1152 * find the second name.1153 */1154while((second < line + llen) &&isspace(*second))1155 second++;11561157if(line + llen <= second)1158goto free_and_fail1;1159if(*second =='"') {1160if(unquote_c_style(&sp, second, NULL))1161goto free_and_fail1;1162 cp =skip_tree_prefix(sp.buf, sp.len);1163if(!cp)1164goto free_and_fail1;1165/* They must match, otherwise ignore */1166if(strcmp(cp, first.buf))1167goto free_and_fail1;1168strbuf_release(&sp);1169returnstrbuf_detach(&first, NULL);1170}11711172/* unquoted second */1173 cp =skip_tree_prefix(second, line + llen - second);1174if(!cp)1175goto free_and_fail1;1176if(line + llen - cp != first.len ||1177memcmp(first.buf, cp, first.len))1178goto free_and_fail1;1179returnstrbuf_detach(&first, NULL);11801181 free_and_fail1:1182strbuf_release(&first);1183strbuf_release(&sp);1184return NULL;1185}11861187/* unquoted first name */1188 name =skip_tree_prefix(line, llen);1189if(!name)1190return NULL;11911192/*1193 * since the first name is unquoted, a dq if exists must be1194 * the beginning of the second name.1195 */1196for(second = name; second < line + llen; second++) {1197if(*second =='"') {1198struct strbuf sp = STRBUF_INIT;1199const char*np;12001201if(unquote_c_style(&sp, second, NULL))1202goto free_and_fail2;12031204 np =skip_tree_prefix(sp.buf, sp.len);1205if(!np)1206goto free_and_fail2;12071208 len = sp.buf + sp.len - np;1209if(len < second - name &&1210!strncmp(np, name, len) &&1211isspace(name[len])) {1212/* Good */1213strbuf_remove(&sp,0, np - sp.buf);1214returnstrbuf_detach(&sp, NULL);1215}12161217 free_and_fail2:1218strbuf_release(&sp);1219return NULL;1220}1221}12221223/*1224 * Accept a name only if it shows up twice, exactly the same1225 * form.1226 */1227 second =strchr(name,'\n');1228if(!second)1229return NULL;1230 line_len = second - name;1231for(len =0; ; len++) {1232switch(name[len]) {1233default:1234continue;1235case'\n':1236return NULL;1237case'\t':case' ':1238/*1239 * Is this the separator between the preimage1240 * and the postimage pathname? Again, we are1241 * only interested in the case where there is1242 * no rename, as this is only to set def_name1243 * and a rename patch has the names elsewhere1244 * in an unambiguous form.1245 */1246if(!name[len +1])1247return NULL;/* no postimage name */1248 second =skip_tree_prefix(name + len +1,1249 line_len - (len +1));1250if(!second)1251return NULL;1252/*1253 * Does len bytes starting at "name" and "second"1254 * (that are separated by one HT or SP we just1255 * found) exactly match?1256 */1257if(second[len] =='\n'&& !strncmp(name, second, len))1258returnxmemdupz(name, len);1259}1260}1261}12621263/* Verify that we recognize the lines following a git header */1264static intparse_git_header(const char*line,int len,unsigned int size,struct patch *patch)1265{1266unsigned long offset;12671268/* A git diff has explicit new/delete information, so we don't guess */1269 patch->is_new =0;1270 patch->is_delete =0;12711272/*1273 * Some things may not have the old name in the1274 * rest of the headers anywhere (pure mode changes,1275 * or removing or adding empty files), so we get1276 * the default name from the header.1277 */1278 patch->def_name =git_header_name(line, len);1279if(patch->def_name && root) {1280char*s =xmalloc(root_len +strlen(patch->def_name) +1);1281strcpy(s, root);1282strcpy(s + root_len, patch->def_name);1283free(patch->def_name);1284 patch->def_name = s;1285}12861287 line += len;1288 size -= len;1289 linenr++;1290for(offset = len ; size >0; offset += len, size -= len, line += len, linenr++) {1291static const struct opentry {1292const char*str;1293int(*fn)(const char*,struct patch *);1294} optable[] = {1295{"@@ -", gitdiff_hdrend },1296{"--- ", gitdiff_oldname },1297{"+++ ", gitdiff_newname },1298{"old mode ", gitdiff_oldmode },1299{"new mode ", gitdiff_newmode },1300{"deleted file mode ", gitdiff_delete },1301{"new file mode ", gitdiff_newfile },1302{"copy from ", gitdiff_copysrc },1303{"copy to ", gitdiff_copydst },1304{"rename old ", gitdiff_renamesrc },1305{"rename new ", gitdiff_renamedst },1306{"rename from ", gitdiff_renamesrc },1307{"rename to ", gitdiff_renamedst },1308{"similarity index ", gitdiff_similarity },1309{"dissimilarity index ", gitdiff_dissimilarity },1310{"index ", gitdiff_index },1311{"", gitdiff_unrecognized },1312};1313int i;13141315 len =linelen(line, size);1316if(!len || line[len-1] !='\n')1317break;1318for(i =0; i <ARRAY_SIZE(optable); i++) {1319const struct opentry *p = optable + i;1320int oplen =strlen(p->str);1321if(len < oplen ||memcmp(p->str, line, oplen))1322continue;1323if(p->fn(line + oplen, patch) <0)1324return offset;1325break;1326}1327}13281329return offset;1330}13311332static intparse_num(const char*line,unsigned long*p)1333{1334char*ptr;13351336if(!isdigit(*line))1337return0;1338*p =strtoul(line, &ptr,10);1339return ptr - line;1340}13411342static intparse_range(const char*line,int len,int offset,const char*expect,1343unsigned long*p1,unsigned long*p2)1344{1345int digits, ex;13461347if(offset <0|| offset >= len)1348return-1;1349 line += offset;1350 len -= offset;13511352 digits =parse_num(line, p1);1353if(!digits)1354return-1;13551356 offset += digits;1357 line += digits;1358 len -= digits;13591360*p2 =1;1361if(*line ==',') {1362 digits =parse_num(line+1, p2);1363if(!digits)1364return-1;13651366 offset += digits+1;1367 line += digits+1;1368 len -= digits+1;1369}13701371 ex =strlen(expect);1372if(ex > len)1373return-1;1374if(memcmp(line, expect, ex))1375return-1;13761377return offset + ex;1378}13791380static voidrecount_diff(const char*line,int size,struct fragment *fragment)1381{1382int oldlines =0, newlines =0, ret =0;13831384if(size <1) {1385warning("recount: ignore empty hunk");1386return;1387}13881389for(;;) {1390int len =linelen(line, size);1391 size -= len;1392 line += len;13931394if(size <1)1395break;13961397switch(*line) {1398case' ':case'\n':1399 newlines++;1400/* fall through */1401case'-':1402 oldlines++;1403continue;1404case'+':1405 newlines++;1406continue;1407case'\\':1408continue;1409case'@':1410 ret = size <3||prefixcmp(line,"@@ ");1411break;1412case'd':1413 ret = size <5||prefixcmp(line,"diff ");1414break;1415default:1416 ret = -1;1417break;1418}1419if(ret) {1420warning(_("recount: unexpected line: %.*s"),1421(int)linelen(line, size), line);1422return;1423}1424break;1425}1426 fragment->oldlines = oldlines;1427 fragment->newlines = newlines;1428}14291430/*1431 * Parse a unified diff fragment header of the1432 * form "@@ -a,b +c,d @@"1433 */1434static intparse_fragment_header(const char*line,int len,struct fragment *fragment)1435{1436int offset;14371438if(!len || line[len-1] !='\n')1439return-1;14401441/* Figure out the number of lines in a fragment */1442 offset =parse_range(line, len,4," +", &fragment->oldpos, &fragment->oldlines);1443 offset =parse_range(line, len, offset," @@", &fragment->newpos, &fragment->newlines);14441445return offset;1446}14471448static intfind_header(const char*line,unsigned long size,int*hdrsize,struct patch *patch)1449{1450unsigned long offset, len;14511452 patch->is_toplevel_relative =0;1453 patch->is_rename = patch->is_copy =0;1454 patch->is_new = patch->is_delete = -1;1455 patch->old_mode = patch->new_mode =0;1456 patch->old_name = patch->new_name = NULL;1457for(offset =0; size >0; offset += len, size -= len, line += len, linenr++) {1458unsigned long nextlen;14591460 len =linelen(line, size);1461if(!len)1462break;14631464/* Testing this early allows us to take a few shortcuts.. */1465if(len <6)1466continue;14671468/*1469 * Make sure we don't find any unconnected patch fragments.1470 * That's a sign that we didn't find a header, and that a1471 * patch has become corrupted/broken up.1472 */1473if(!memcmp("@@ -", line,4)) {1474struct fragment dummy;1475if(parse_fragment_header(line, len, &dummy) <0)1476continue;1477die(_("patch fragment without header at line%d: %.*s"),1478 linenr, (int)len-1, line);1479}14801481if(size < len +6)1482break;14831484/*1485 * Git patch? It might not have a real patch, just a rename1486 * or mode change, so we handle that specially1487 */1488if(!memcmp("diff --git ", line,11)) {1489int git_hdr_len =parse_git_header(line, len, size, patch);1490if(git_hdr_len <= len)1491continue;1492if(!patch->old_name && !patch->new_name) {1493if(!patch->def_name)1494die(Q_("git diff header lacks filename information when removing "1495"%dleading pathname component (line%d)",1496"git diff header lacks filename information when removing "1497"%dleading pathname components (line%d)",1498 p_value),1499 p_value, linenr);1500 patch->old_name =xstrdup(patch->def_name);1501 patch->new_name =xstrdup(patch->def_name);1502}1503if(!patch->is_delete && !patch->new_name)1504die("git diff header lacks filename information "1505"(line%d)", linenr);1506 patch->is_toplevel_relative =1;1507*hdrsize = git_hdr_len;1508return offset;1509}15101511/* --- followed by +++ ? */1512if(memcmp("--- ", line,4) ||memcmp("+++ ", line + len,4))1513continue;15141515/*1516 * We only accept unified patches, so we want it to1517 * at least have "@@ -a,b +c,d @@\n", which is 14 chars1518 * minimum ("@@ -0,0 +1 @@\n" is the shortest).1519 */1520 nextlen =linelen(line + len, size - len);1521if(size < nextlen +14||memcmp("@@ -", line + len + nextlen,4))1522continue;15231524/* Ok, we'll consider it a patch */1525parse_traditional_patch(line, line+len, patch);1526*hdrsize = len + nextlen;1527 linenr +=2;1528return offset;1529}1530return-1;1531}15321533static voidrecord_ws_error(unsigned result,const char*line,int len,int linenr)1534{1535char*err;15361537if(!result)1538return;15391540 whitespace_error++;1541if(squelch_whitespace_errors &&1542 squelch_whitespace_errors < whitespace_error)1543return;15441545 err =whitespace_error_string(result);1546fprintf(stderr,"%s:%d:%s.\n%.*s\n",1547 patch_input_file, linenr, err, len, line);1548free(err);1549}15501551static voidcheck_whitespace(const char*line,int len,unsigned ws_rule)1552{1553unsigned result =ws_check(line +1, len -1, ws_rule);15541555record_ws_error(result, line +1, len -2, linenr);1556}15571558/*1559 * Parse a unified diff. Note that this really needs to parse each1560 * fragment separately, since the only way to know the difference1561 * between a "---" that is part of a patch, and a "---" that starts1562 * the next patch is to look at the line counts..1563 */1564static intparse_fragment(const char*line,unsigned long size,1565struct patch *patch,struct fragment *fragment)1566{1567int added, deleted;1568int len =linelen(line, size), offset;1569unsigned long oldlines, newlines;1570unsigned long leading, trailing;15711572 offset =parse_fragment_header(line, len, fragment);1573if(offset <0)1574return-1;1575if(offset >0&& patch->recount)1576recount_diff(line + offset, size - offset, fragment);1577 oldlines = fragment->oldlines;1578 newlines = fragment->newlines;1579 leading =0;1580 trailing =0;15811582/* Parse the thing.. */1583 line += len;1584 size -= len;1585 linenr++;1586 added = deleted =0;1587for(offset = len;15880< size;1589 offset += len, size -= len, line += len, linenr++) {1590if(!oldlines && !newlines)1591break;1592 len =linelen(line, size);1593if(!len || line[len-1] !='\n')1594return-1;1595switch(*line) {1596default:1597return-1;1598case'\n':/* newer GNU diff, an empty context line */1599case' ':1600 oldlines--;1601 newlines--;1602if(!deleted && !added)1603 leading++;1604 trailing++;1605break;1606case'-':1607if(apply_in_reverse &&1608 ws_error_action != nowarn_ws_error)1609check_whitespace(line, len, patch->ws_rule);1610 deleted++;1611 oldlines--;1612 trailing =0;1613break;1614case'+':1615if(!apply_in_reverse &&1616 ws_error_action != nowarn_ws_error)1617check_whitespace(line, len, patch->ws_rule);1618 added++;1619 newlines--;1620 trailing =0;1621break;16221623/*1624 * We allow "\ No newline at end of file". Depending1625 * on locale settings when the patch was produced we1626 * don't know what this line looks like. The only1627 * thing we do know is that it begins with "\ ".1628 * Checking for 12 is just for sanity check -- any1629 * l10n of "\ No newline..." is at least that long.1630 */1631case'\\':1632if(len <12||memcmp(line,"\\",2))1633return-1;1634break;1635}1636}1637if(oldlines || newlines)1638return-1;1639 fragment->leading = leading;1640 fragment->trailing = trailing;16411642/*1643 * If a fragment ends with an incomplete line, we failed to include1644 * it in the above loop because we hit oldlines == newlines == 01645 * before seeing it.1646 */1647if(12< size && !memcmp(line,"\\",2))1648 offset +=linelen(line, size);16491650 patch->lines_added += added;1651 patch->lines_deleted += deleted;16521653if(0< patch->is_new && oldlines)1654returnerror(_("new file depends on old contents"));1655if(0< patch->is_delete && newlines)1656returnerror(_("deleted file still has contents"));1657return offset;1658}16591660/*1661 * We have seen "diff --git a/... b/..." header (or a traditional patch1662 * header). Read hunks that belong to this patch into fragments and hang1663 * them to the given patch structure.1664 *1665 * The (fragment->patch, fragment->size) pair points into the memory given1666 * by the caller, not a copy, when we return.1667 */1668static intparse_single_patch(const char*line,unsigned long size,struct patch *patch)1669{1670unsigned long offset =0;1671unsigned long oldlines =0, newlines =0, context =0;1672struct fragment **fragp = &patch->fragments;16731674while(size >4&& !memcmp(line,"@@ -",4)) {1675struct fragment *fragment;1676int len;16771678 fragment =xcalloc(1,sizeof(*fragment));1679 fragment->linenr = linenr;1680 len =parse_fragment(line, size, patch, fragment);1681if(len <=0)1682die(_("corrupt patch at line%d"), linenr);1683 fragment->patch = line;1684 fragment->size = len;1685 oldlines += fragment->oldlines;1686 newlines += fragment->newlines;1687 context += fragment->leading + fragment->trailing;16881689*fragp = fragment;1690 fragp = &fragment->next;16911692 offset += len;1693 line += len;1694 size -= len;1695}16961697/*1698 * If something was removed (i.e. we have old-lines) it cannot1699 * be creation, and if something was added it cannot be1700 * deletion. However, the reverse is not true; --unified=01701 * patches that only add are not necessarily creation even1702 * though they do not have any old lines, and ones that only1703 * delete are not necessarily deletion.1704 *1705 * Unfortunately, a real creation/deletion patch do _not_ have1706 * any context line by definition, so we cannot safely tell it1707 * apart with --unified=0 insanity. At least if the patch has1708 * more than one hunk it is not creation or deletion.1709 */1710if(patch->is_new <0&&1711(oldlines || (patch->fragments && patch->fragments->next)))1712 patch->is_new =0;1713if(patch->is_delete <0&&1714(newlines || (patch->fragments && patch->fragments->next)))1715 patch->is_delete =0;17161717if(0< patch->is_new && oldlines)1718die(_("new file%sdepends on old contents"), patch->new_name);1719if(0< patch->is_delete && newlines)1720die(_("deleted file%sstill has contents"), patch->old_name);1721if(!patch->is_delete && !newlines && context)1722fprintf_ln(stderr,1723_("** warning: "1724"file%sbecomes empty but is not deleted"),1725 patch->new_name);17261727return offset;1728}17291730staticinlineintmetadata_changes(struct patch *patch)1731{1732return patch->is_rename >0||1733 patch->is_copy >0||1734 patch->is_new >0||1735 patch->is_delete ||1736(patch->old_mode && patch->new_mode &&1737 patch->old_mode != patch->new_mode);1738}17391740static char*inflate_it(const void*data,unsigned long size,1741unsigned long inflated_size)1742{1743 git_zstream stream;1744void*out;1745int st;17461747memset(&stream,0,sizeof(stream));17481749 stream.next_in = (unsigned char*)data;1750 stream.avail_in = size;1751 stream.next_out = out =xmalloc(inflated_size);1752 stream.avail_out = inflated_size;1753git_inflate_init(&stream);1754 st =git_inflate(&stream, Z_FINISH);1755git_inflate_end(&stream);1756if((st != Z_STREAM_END) || stream.total_out != inflated_size) {1757free(out);1758return NULL;1759}1760return out;1761}17621763/*1764 * Read a binary hunk and return a new fragment; fragment->patch1765 * points at an allocated memory that the caller must free, so1766 * it is marked as "->free_patch = 1".1767 */1768static struct fragment *parse_binary_hunk(char**buf_p,1769unsigned long*sz_p,1770int*status_p,1771int*used_p)1772{1773/*1774 * Expect a line that begins with binary patch method ("literal"1775 * or "delta"), followed by the length of data before deflating.1776 * a sequence of 'length-byte' followed by base-85 encoded data1777 * should follow, terminated by a newline.1778 *1779 * Each 5-byte sequence of base-85 encodes up to 4 bytes,1780 * and we would limit the patch line to 66 characters,1781 * so one line can fit up to 13 groups that would decode1782 * to 52 bytes max. The length byte 'A'-'Z' corresponds1783 * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.1784 */1785int llen, used;1786unsigned long size = *sz_p;1787char*buffer = *buf_p;1788int patch_method;1789unsigned long origlen;1790char*data = NULL;1791int hunk_size =0;1792struct fragment *frag;17931794 llen =linelen(buffer, size);1795 used = llen;17961797*status_p =0;17981799if(!prefixcmp(buffer,"delta ")) {1800 patch_method = BINARY_DELTA_DEFLATED;1801 origlen =strtoul(buffer +6, NULL,10);1802}1803else if(!prefixcmp(buffer,"literal ")) {1804 patch_method = BINARY_LITERAL_DEFLATED;1805 origlen =strtoul(buffer +8, NULL,10);1806}1807else1808return NULL;18091810 linenr++;1811 buffer += llen;1812while(1) {1813int byte_length, max_byte_length, newsize;1814 llen =linelen(buffer, size);1815 used += llen;1816 linenr++;1817if(llen ==1) {1818/* consume the blank line */1819 buffer++;1820 size--;1821break;1822}1823/*1824 * Minimum line is "A00000\n" which is 7-byte long,1825 * and the line length must be multiple of 5 plus 2.1826 */1827if((llen <7) || (llen-2) %5)1828goto corrupt;1829 max_byte_length = (llen -2) /5*4;1830 byte_length = *buffer;1831if('A'<= byte_length && byte_length <='Z')1832 byte_length = byte_length -'A'+1;1833else if('a'<= byte_length && byte_length <='z')1834 byte_length = byte_length -'a'+27;1835else1836goto corrupt;1837/* if the input length was not multiple of 4, we would1838 * have filler at the end but the filler should never1839 * exceed 3 bytes1840 */1841if(max_byte_length < byte_length ||1842 byte_length <= max_byte_length -4)1843goto corrupt;1844 newsize = hunk_size + byte_length;1845 data =xrealloc(data, newsize);1846if(decode_85(data + hunk_size, buffer +1, byte_length))1847goto corrupt;1848 hunk_size = newsize;1849 buffer += llen;1850 size -= llen;1851}18521853 frag =xcalloc(1,sizeof(*frag));1854 frag->patch =inflate_it(data, hunk_size, origlen);1855 frag->free_patch =1;1856if(!frag->patch)1857goto corrupt;1858free(data);1859 frag->size = origlen;1860*buf_p = buffer;1861*sz_p = size;1862*used_p = used;1863 frag->binary_patch_method = patch_method;1864return frag;18651866 corrupt:1867free(data);1868*status_p = -1;1869error(_("corrupt binary patch at line%d: %.*s"),1870 linenr-1, llen-1, buffer);1871return NULL;1872}18731874static intparse_binary(char*buffer,unsigned long size,struct patch *patch)1875{1876/*1877 * We have read "GIT binary patch\n"; what follows is a line1878 * that says the patch method (currently, either "literal" or1879 * "delta") and the length of data before deflating; a1880 * sequence of 'length-byte' followed by base-85 encoded data1881 * follows.1882 *1883 * When a binary patch is reversible, there is another binary1884 * hunk in the same format, starting with patch method (either1885 * "literal" or "delta") with the length of data, and a sequence1886 * of length-byte + base-85 encoded data, terminated with another1887 * empty line. This data, when applied to the postimage, produces1888 * the preimage.1889 */1890struct fragment *forward;1891struct fragment *reverse;1892int status;1893int used, used_1;18941895 forward =parse_binary_hunk(&buffer, &size, &status, &used);1896if(!forward && !status)1897/* there has to be one hunk (forward hunk) */1898returnerror(_("unrecognized binary patch at line%d"), linenr-1);1899if(status)1900/* otherwise we already gave an error message */1901return status;19021903 reverse =parse_binary_hunk(&buffer, &size, &status, &used_1);1904if(reverse)1905 used += used_1;1906else if(status) {1907/*1908 * Not having reverse hunk is not an error, but having1909 * a corrupt reverse hunk is.1910 */1911free((void*) forward->patch);1912free(forward);1913return status;1914}1915 forward->next = reverse;1916 patch->fragments = forward;1917 patch->is_binary =1;1918return used;1919}19201921/*1922 * Read the patch text in "buffer" taht extends for "size" bytes; stop1923 * reading after seeing a single patch (i.e. changes to a single file).1924 * Create fragments (i.e. patch hunks) and hang them to the given patch.1925 * Return the number of bytes consumed, so that the caller can call us1926 * again for the next patch.1927 */1928static intparse_chunk(char*buffer,unsigned long size,struct patch *patch)1929{1930int hdrsize, patchsize;1931int offset =find_header(buffer, size, &hdrsize, patch);19321933if(offset <0)1934return offset;19351936 patch->ws_rule =whitespace_rule(patch->new_name1937? patch->new_name1938: patch->old_name);19391940 patchsize =parse_single_patch(buffer + offset + hdrsize,1941 size - offset - hdrsize, patch);19421943if(!patchsize) {1944static const char*binhdr[] = {1945"Binary files ",1946"Files ",1947 NULL,1948};1949static const char git_binary[] ="GIT binary patch\n";1950int i;1951int hd = hdrsize + offset;1952unsigned long llen =linelen(buffer + hd, size - hd);19531954if(llen ==sizeof(git_binary) -1&&1955!memcmp(git_binary, buffer + hd, llen)) {1956int used;1957 linenr++;1958 used =parse_binary(buffer + hd + llen,1959 size - hd - llen, patch);1960if(used)1961 patchsize = used + llen;1962else1963 patchsize =0;1964}1965else if(!memcmp(" differ\n", buffer + hd + llen -8,8)) {1966for(i =0; binhdr[i]; i++) {1967int len =strlen(binhdr[i]);1968if(len < size - hd &&1969!memcmp(binhdr[i], buffer + hd, len)) {1970 linenr++;1971 patch->is_binary =1;1972 patchsize = llen;1973break;1974}1975}1976}19771978/* Empty patch cannot be applied if it is a text patch1979 * without metadata change. A binary patch appears1980 * empty to us here.1981 */1982if((apply || check) &&1983(!patch->is_binary && !metadata_changes(patch)))1984die(_("patch with only garbage at line%d"), linenr);1985}19861987return offset + hdrsize + patchsize;1988}19891990#define swap(a,b) myswap((a),(b),sizeof(a))19911992#define myswap(a, b, size) do { \1993 unsigned char mytmp[size]; \1994 memcpy(mytmp, &a, size); \1995 memcpy(&a, &b, size); \1996 memcpy(&b, mytmp, size); \1997} while (0)19981999static voidreverse_patches(struct patch *p)2000{2001for(; p; p = p->next) {2002struct fragment *frag = p->fragments;20032004swap(p->new_name, p->old_name);2005swap(p->new_mode, p->old_mode);2006swap(p->is_new, p->is_delete);2007swap(p->lines_added, p->lines_deleted);2008swap(p->old_sha1_prefix, p->new_sha1_prefix);20092010for(; frag; frag = frag->next) {2011swap(frag->newpos, frag->oldpos);2012swap(frag->newlines, frag->oldlines);2013}2014}2015}20162017static const char pluses[] =2018"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";2019static const char minuses[]=2020"----------------------------------------------------------------------";20212022static voidshow_stats(struct patch *patch)2023{2024struct strbuf qname = STRBUF_INIT;2025char*cp = patch->new_name ? patch->new_name : patch->old_name;2026int max, add, del;20272028quote_c_style(cp, &qname, NULL,0);20292030/*2031 * "scale" the filename2032 */2033 max = max_len;2034if(max >50)2035 max =50;20362037if(qname.len > max) {2038 cp =strchr(qname.buf + qname.len +3- max,'/');2039if(!cp)2040 cp = qname.buf + qname.len +3- max;2041strbuf_splice(&qname,0, cp - qname.buf,"...",3);2042}20432044if(patch->is_binary) {2045printf(" %-*s | Bin\n", max, qname.buf);2046strbuf_release(&qname);2047return;2048}20492050printf(" %-*s |", max, qname.buf);2051strbuf_release(&qname);20522053/*2054 * scale the add/delete2055 */2056 max = max + max_change >70?70- max : max_change;2057 add = patch->lines_added;2058 del = patch->lines_deleted;20592060if(max_change >0) {2061int total = ((add + del) * max + max_change /2) / max_change;2062 add = (add * max + max_change /2) / max_change;2063 del = total - add;2064}2065printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,2066 add, pluses, del, minuses);2067}20682069static intread_old_data(struct stat *st,const char*path,struct strbuf *buf)2070{2071switch(st->st_mode & S_IFMT) {2072case S_IFLNK:2073if(strbuf_readlink(buf, path, st->st_size) <0)2074returnerror(_("unable to read symlink%s"), path);2075return0;2076case S_IFREG:2077if(strbuf_read_file(buf, path, st->st_size) != st->st_size)2078returnerror(_("unable to open or read%s"), path);2079convert_to_git(path, buf->buf, buf->len, buf,0);2080return0;2081default:2082return-1;2083}2084}20852086/*2087 * Update the preimage, and the common lines in postimage,2088 * from buffer buf of length len. If postlen is 0 the postimage2089 * is updated in place, otherwise it's updated on a new buffer2090 * of length postlen2091 */20922093static voidupdate_pre_post_images(struct image *preimage,2094struct image *postimage,2095char*buf,2096size_t len,size_t postlen)2097{2098int i, ctx;2099char*new, *old, *fixed;2100struct image fixed_preimage;21012102/*2103 * Update the preimage with whitespace fixes. Note that we2104 * are not losing preimage->buf -- apply_one_fragment() will2105 * free "oldlines".2106 */2107prepare_image(&fixed_preimage, buf, len,1);2108assert(fixed_preimage.nr == preimage->nr);2109for(i =0; i < preimage->nr; i++)2110 fixed_preimage.line[i].flag = preimage->line[i].flag;2111free(preimage->line_allocated);2112*preimage = fixed_preimage;21132114/*2115 * Adjust the common context lines in postimage. This can be2116 * done in-place when we are shrinking it with whitespace2117 * fixing, but needs a new buffer when ignoring whitespace or2118 * expanding leading tabs to spaces.2119 *2120 * We trust the caller to tell us if the update can be done2121 * in place (postlen==0) or not.2122 */2123 old = postimage->buf;2124if(postlen)2125new= postimage->buf =xmalloc(postlen);2126else2127new= old;2128 fixed = preimage->buf;2129for(i = ctx =0; i < postimage->nr; i++) {2130size_t len = postimage->line[i].len;2131if(!(postimage->line[i].flag & LINE_COMMON)) {2132/* an added line -- no counterparts in preimage */2133memmove(new, old, len);2134 old += len;2135new+= len;2136continue;2137}21382139/* a common context -- skip it in the original postimage */2140 old += len;21412142/* and find the corresponding one in the fixed preimage */2143while(ctx < preimage->nr &&2144!(preimage->line[ctx].flag & LINE_COMMON)) {2145 fixed += preimage->line[ctx].len;2146 ctx++;2147}2148if(preimage->nr <= ctx)2149die(_("oops"));21502151/* and copy it in, while fixing the line length */2152 len = preimage->line[ctx].len;2153memcpy(new, fixed, len);2154new+= len;2155 fixed += len;2156 postimage->line[i].len = len;2157 ctx++;2158}21592160/* Fix the length of the whole thing */2161 postimage->len =new- postimage->buf;2162}21632164static intmatch_fragment(struct image *img,2165struct image *preimage,2166struct image *postimage,2167unsigned longtry,2168int try_lno,2169unsigned ws_rule,2170int match_beginning,int match_end)2171{2172int i;2173char*fixed_buf, *buf, *orig, *target;2174struct strbuf fixed;2175size_t fixed_len, postlen;2176int preimage_limit;21772178if(preimage->nr + try_lno <= img->nr) {2179/*2180 * The hunk falls within the boundaries of img.2181 */2182 preimage_limit = preimage->nr;2183if(match_end && (preimage->nr + try_lno != img->nr))2184return0;2185}else if(ws_error_action == correct_ws_error &&2186(ws_rule & WS_BLANK_AT_EOF)) {2187/*2188 * This hunk extends beyond the end of img, and we are2189 * removing blank lines at the end of the file. This2190 * many lines from the beginning of the preimage must2191 * match with img, and the remainder of the preimage2192 * must be blank.2193 */2194 preimage_limit = img->nr - try_lno;2195}else{2196/*2197 * The hunk extends beyond the end of the img and2198 * we are not removing blanks at the end, so we2199 * should reject the hunk at this position.2200 */2201return0;2202}22032204if(match_beginning && try_lno)2205return0;22062207/* Quick hash check */2208for(i =0; i < preimage_limit; i++)2209if((img->line[try_lno + i].flag & LINE_PATCHED) ||2210(preimage->line[i].hash != img->line[try_lno + i].hash))2211return0;22122213if(preimage_limit == preimage->nr) {2214/*2215 * Do we have an exact match? If we were told to match2216 * at the end, size must be exactly at try+fragsize,2217 * otherwise try+fragsize must be still within the preimage,2218 * and either case, the old piece should match the preimage2219 * exactly.2220 */2221if((match_end2222? (try+ preimage->len == img->len)2223: (try+ preimage->len <= img->len)) &&2224!memcmp(img->buf +try, preimage->buf, preimage->len))2225return1;2226}else{2227/*2228 * The preimage extends beyond the end of img, so2229 * there cannot be an exact match.2230 *2231 * There must be one non-blank context line that match2232 * a line before the end of img.2233 */2234char*buf_end;22352236 buf = preimage->buf;2237 buf_end = buf;2238for(i =0; i < preimage_limit; i++)2239 buf_end += preimage->line[i].len;22402241for( ; buf < buf_end; buf++)2242if(!isspace(*buf))2243break;2244if(buf == buf_end)2245return0;2246}22472248/*2249 * No exact match. If we are ignoring whitespace, run a line-by-line2250 * fuzzy matching. We collect all the line length information because2251 * we need it to adjust whitespace if we match.2252 */2253if(ws_ignore_action == ignore_ws_change) {2254size_t imgoff =0;2255size_t preoff =0;2256size_t postlen = postimage->len;2257size_t extra_chars;2258char*preimage_eof;2259char*preimage_end;2260for(i =0; i < preimage_limit; i++) {2261size_t prelen = preimage->line[i].len;2262size_t imglen = img->line[try_lno+i].len;22632264if(!fuzzy_matchlines(img->buf +try+ imgoff, imglen,2265 preimage->buf + preoff, prelen))2266return0;2267if(preimage->line[i].flag & LINE_COMMON)2268 postlen += imglen - prelen;2269 imgoff += imglen;2270 preoff += prelen;2271}22722273/*2274 * Ok, the preimage matches with whitespace fuzz.2275 *2276 * imgoff now holds the true length of the target that2277 * matches the preimage before the end of the file.2278 *2279 * Count the number of characters in the preimage that fall2280 * beyond the end of the file and make sure that all of them2281 * are whitespace characters. (This can only happen if2282 * we are removing blank lines at the end of the file.)2283 */2284 buf = preimage_eof = preimage->buf + preoff;2285for( ; i < preimage->nr; i++)2286 preoff += preimage->line[i].len;2287 preimage_end = preimage->buf + preoff;2288for( ; buf < preimage_end; buf++)2289if(!isspace(*buf))2290return0;22912292/*2293 * Update the preimage and the common postimage context2294 * lines to use the same whitespace as the target.2295 * If whitespace is missing in the target (i.e.2296 * if the preimage extends beyond the end of the file),2297 * use the whitespace from the preimage.2298 */2299 extra_chars = preimage_end - preimage_eof;2300strbuf_init(&fixed, imgoff + extra_chars);2301strbuf_add(&fixed, img->buf +try, imgoff);2302strbuf_add(&fixed, preimage_eof, extra_chars);2303 fixed_buf =strbuf_detach(&fixed, &fixed_len);2304update_pre_post_images(preimage, postimage,2305 fixed_buf, fixed_len, postlen);2306return1;2307}23082309if(ws_error_action != correct_ws_error)2310return0;23112312/*2313 * The hunk does not apply byte-by-byte, but the hash says2314 * it might with whitespace fuzz. We haven't been asked to2315 * ignore whitespace, we were asked to correct whitespace2316 * errors, so let's try matching after whitespace correction.2317 *2318 * The preimage may extend beyond the end of the file,2319 * but in this loop we will only handle the part of the2320 * preimage that falls within the file.2321 */2322strbuf_init(&fixed, preimage->len +1);2323 orig = preimage->buf;2324 target = img->buf +try;2325 postlen =0;2326for(i =0; i < preimage_limit; i++) {2327size_t oldlen = preimage->line[i].len;2328size_t tgtlen = img->line[try_lno + i].len;2329size_t fixstart = fixed.len;2330struct strbuf tgtfix;2331int match;23322333/* Try fixing the line in the preimage */2334ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);23352336/* Try fixing the line in the target */2337strbuf_init(&tgtfix, tgtlen);2338ws_fix_copy(&tgtfix, target, tgtlen, ws_rule, NULL);23392340/*2341 * If they match, either the preimage was based on2342 * a version before our tree fixed whitespace breakage,2343 * or we are lacking a whitespace-fix patch the tree2344 * the preimage was based on already had (i.e. target2345 * has whitespace breakage, the preimage doesn't).2346 * In either case, we are fixing the whitespace breakages2347 * so we might as well take the fix together with their2348 * real change.2349 */2350 match = (tgtfix.len == fixed.len - fixstart &&2351!memcmp(tgtfix.buf, fixed.buf + fixstart,2352 fixed.len - fixstart));2353 postlen += tgtfix.len;23542355strbuf_release(&tgtfix);2356if(!match)2357goto unmatch_exit;23582359 orig += oldlen;2360 target += tgtlen;2361}236223632364/*2365 * Now handle the lines in the preimage that falls beyond the2366 * end of the file (if any). They will only match if they are2367 * empty or only contain whitespace (if WS_BLANK_AT_EOL is2368 * false).2369 */2370for( ; i < preimage->nr; i++) {2371size_t fixstart = fixed.len;/* start of the fixed preimage */2372size_t oldlen = preimage->line[i].len;2373int j;23742375/* Try fixing the line in the preimage */2376ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);23772378for(j = fixstart; j < fixed.len; j++)2379if(!isspace(fixed.buf[j]))2380goto unmatch_exit;23812382 orig += oldlen;2383}23842385/*2386 * Yes, the preimage is based on an older version that still2387 * has whitespace breakages unfixed, and fixing them makes the2388 * hunk match. Update the context lines in the postimage.2389 */2390 fixed_buf =strbuf_detach(&fixed, &fixed_len);2391if(postlen < postimage->len)2392 postlen =0;2393update_pre_post_images(preimage, postimage,2394 fixed_buf, fixed_len, postlen);2395return1;23962397 unmatch_exit:2398strbuf_release(&fixed);2399return0;2400}24012402static intfind_pos(struct image *img,2403struct image *preimage,2404struct image *postimage,2405int line,2406unsigned ws_rule,2407int match_beginning,int match_end)2408{2409int i;2410unsigned long backwards, forwards,try;2411int backwards_lno, forwards_lno, try_lno;24122413/*2414 * If match_beginning or match_end is specified, there is no2415 * point starting from a wrong line that will never match and2416 * wander around and wait for a match at the specified end.2417 */2418if(match_beginning)2419 line =0;2420else if(match_end)2421 line = img->nr - preimage->nr;24222423/*2424 * Because the comparison is unsigned, the following test2425 * will also take care of a negative line number that can2426 * result when match_end and preimage is larger than the target.2427 */2428if((size_t) line > img->nr)2429 line = img->nr;24302431try=0;2432for(i =0; i < line; i++)2433try+= img->line[i].len;24342435/*2436 * There's probably some smart way to do this, but I'll leave2437 * that to the smart and beautiful people. I'm simple and stupid.2438 */2439 backwards =try;2440 backwards_lno = line;2441 forwards =try;2442 forwards_lno = line;2443 try_lno = line;24442445for(i =0; ; i++) {2446if(match_fragment(img, preimage, postimage,2447try, try_lno, ws_rule,2448 match_beginning, match_end))2449return try_lno;24502451 again:2452if(backwards_lno ==0&& forwards_lno == img->nr)2453break;24542455if(i &1) {2456if(backwards_lno ==0) {2457 i++;2458goto again;2459}2460 backwards_lno--;2461 backwards -= img->line[backwards_lno].len;2462try= backwards;2463 try_lno = backwards_lno;2464}else{2465if(forwards_lno == img->nr) {2466 i++;2467goto again;2468}2469 forwards += img->line[forwards_lno].len;2470 forwards_lno++;2471try= forwards;2472 try_lno = forwards_lno;2473}24742475}2476return-1;2477}24782479static voidremove_first_line(struct image *img)2480{2481 img->buf += img->line[0].len;2482 img->len -= img->line[0].len;2483 img->line++;2484 img->nr--;2485}24862487static voidremove_last_line(struct image *img)2488{2489 img->len -= img->line[--img->nr].len;2490}24912492/*2493 * The change from "preimage" and "postimage" has been found to2494 * apply at applied_pos (counts in line numbers) in "img".2495 * Update "img" to remove "preimage" and replace it with "postimage".2496 */2497static voidupdate_image(struct image *img,2498int applied_pos,2499struct image *preimage,2500struct image *postimage)2501{2502/*2503 * remove the copy of preimage at offset in img2504 * and replace it with postimage2505 */2506int i, nr;2507size_t remove_count, insert_count, applied_at =0;2508char*result;2509int preimage_limit;25102511/*2512 * If we are removing blank lines at the end of img,2513 * the preimage may extend beyond the end.2514 * If that is the case, we must be careful only to2515 * remove the part of the preimage that falls within2516 * the boundaries of img. Initialize preimage_limit2517 * to the number of lines in the preimage that falls2518 * within the boundaries.2519 */2520 preimage_limit = preimage->nr;2521if(preimage_limit > img->nr - applied_pos)2522 preimage_limit = img->nr - applied_pos;25232524for(i =0; i < applied_pos; i++)2525 applied_at += img->line[i].len;25262527 remove_count =0;2528for(i =0; i < preimage_limit; i++)2529 remove_count += img->line[applied_pos + i].len;2530 insert_count = postimage->len;25312532/* Adjust the contents */2533 result =xmalloc(img->len + insert_count - remove_count +1);2534memcpy(result, img->buf, applied_at);2535memcpy(result + applied_at, postimage->buf, postimage->len);2536memcpy(result + applied_at + postimage->len,2537 img->buf + (applied_at + remove_count),2538 img->len - (applied_at + remove_count));2539free(img->buf);2540 img->buf = result;2541 img->len += insert_count - remove_count;2542 result[img->len] ='\0';25432544/* Adjust the line table */2545 nr = img->nr + postimage->nr - preimage_limit;2546if(preimage_limit < postimage->nr) {2547/*2548 * NOTE: this knows that we never call remove_first_line()2549 * on anything other than pre/post image.2550 */2551 img->line =xrealloc(img->line, nr *sizeof(*img->line));2552 img->line_allocated = img->line;2553}2554if(preimage_limit != postimage->nr)2555memmove(img->line + applied_pos + postimage->nr,2556 img->line + applied_pos + preimage_limit,2557(img->nr - (applied_pos + preimage_limit)) *2558sizeof(*img->line));2559memcpy(img->line + applied_pos,2560 postimage->line,2561 postimage->nr *sizeof(*img->line));2562if(!allow_overlap)2563for(i =0; i < postimage->nr; i++)2564 img->line[applied_pos + i].flag |= LINE_PATCHED;2565 img->nr = nr;2566}25672568/*2569 * Use the patch-hunk text in "frag" to prepare two images (preimage and2570 * postimage) for the hunk. Find lines that match "preimage" in "img" and2571 * replace the part of "img" with "postimage" text.2572 */2573static intapply_one_fragment(struct image *img,struct fragment *frag,2574int inaccurate_eof,unsigned ws_rule,2575int nth_fragment)2576{2577int match_beginning, match_end;2578const char*patch = frag->patch;2579int size = frag->size;2580char*old, *oldlines;2581struct strbuf newlines;2582int new_blank_lines_at_end =0;2583int found_new_blank_lines_at_end =0;2584int hunk_linenr = frag->linenr;2585unsigned long leading, trailing;2586int pos, applied_pos;2587struct image preimage;2588struct image postimage;25892590memset(&preimage,0,sizeof(preimage));2591memset(&postimage,0,sizeof(postimage));2592 oldlines =xmalloc(size);2593strbuf_init(&newlines, size);25942595 old = oldlines;2596while(size >0) {2597char first;2598int len =linelen(patch, size);2599int plen;2600int added_blank_line =0;2601int is_blank_context =0;2602size_t start;26032604if(!len)2605break;26062607/*2608 * "plen" is how much of the line we should use for2609 * the actual patch data. Normally we just remove the2610 * first character on the line, but if the line is2611 * followed by "\ No newline", then we also remove the2612 * last one (which is the newline, of course).2613 */2614 plen = len -1;2615if(len < size && patch[len] =='\\')2616 plen--;2617 first = *patch;2618if(apply_in_reverse) {2619if(first =='-')2620 first ='+';2621else if(first =='+')2622 first ='-';2623}26242625switch(first) {2626case'\n':2627/* Newer GNU diff, empty context line */2628if(plen <0)2629/* ... followed by '\No newline'; nothing */2630break;2631*old++ ='\n';2632strbuf_addch(&newlines,'\n');2633add_line_info(&preimage,"\n",1, LINE_COMMON);2634add_line_info(&postimage,"\n",1, LINE_COMMON);2635 is_blank_context =1;2636break;2637case' ':2638if(plen && (ws_rule & WS_BLANK_AT_EOF) &&2639ws_blank_line(patch +1, plen, ws_rule))2640 is_blank_context =1;2641case'-':2642memcpy(old, patch +1, plen);2643add_line_info(&preimage, old, plen,2644(first ==' '? LINE_COMMON :0));2645 old += plen;2646if(first =='-')2647break;2648/* Fall-through for ' ' */2649case'+':2650/* --no-add does not add new lines */2651if(first =='+'&& no_add)2652break;26532654 start = newlines.len;2655if(first !='+'||2656!whitespace_error ||2657 ws_error_action != correct_ws_error) {2658strbuf_add(&newlines, patch +1, plen);2659}2660else{2661ws_fix_copy(&newlines, patch +1, plen, ws_rule, &applied_after_fixing_ws);2662}2663add_line_info(&postimage, newlines.buf + start, newlines.len - start,2664(first =='+'?0: LINE_COMMON));2665if(first =='+'&&2666(ws_rule & WS_BLANK_AT_EOF) &&2667ws_blank_line(patch +1, plen, ws_rule))2668 added_blank_line =1;2669break;2670case'@':case'\\':2671/* Ignore it, we already handled it */2672break;2673default:2674if(apply_verbosely)2675error(_("invalid start of line: '%c'"), first);2676return-1;2677}2678if(added_blank_line) {2679if(!new_blank_lines_at_end)2680 found_new_blank_lines_at_end = hunk_linenr;2681 new_blank_lines_at_end++;2682}2683else if(is_blank_context)2684;2685else2686 new_blank_lines_at_end =0;2687 patch += len;2688 size -= len;2689 hunk_linenr++;2690}2691if(inaccurate_eof &&2692 old > oldlines && old[-1] =='\n'&&2693 newlines.len >0&& newlines.buf[newlines.len -1] =='\n') {2694 old--;2695strbuf_setlen(&newlines, newlines.len -1);2696}26972698 leading = frag->leading;2699 trailing = frag->trailing;27002701/*2702 * A hunk to change lines at the beginning would begin with2703 * @@ -1,L +N,M @@2704 * but we need to be careful. -U0 that inserts before the second2705 * line also has this pattern.2706 *2707 * And a hunk to add to an empty file would begin with2708 * @@ -0,0 +N,M @@2709 *2710 * In other words, a hunk that is (frag->oldpos <= 1) with or2711 * without leading context must match at the beginning.2712 */2713 match_beginning = (!frag->oldpos ||2714(frag->oldpos ==1&& !unidiff_zero));27152716/*2717 * A hunk without trailing lines must match at the end.2718 * However, we simply cannot tell if a hunk must match end2719 * from the lack of trailing lines if the patch was generated2720 * with unidiff without any context.2721 */2722 match_end = !unidiff_zero && !trailing;27232724 pos = frag->newpos ? (frag->newpos -1) :0;2725 preimage.buf = oldlines;2726 preimage.len = old - oldlines;2727 postimage.buf = newlines.buf;2728 postimage.len = newlines.len;2729 preimage.line = preimage.line_allocated;2730 postimage.line = postimage.line_allocated;27312732for(;;) {27332734 applied_pos =find_pos(img, &preimage, &postimage, pos,2735 ws_rule, match_beginning, match_end);27362737if(applied_pos >=0)2738break;27392740/* Am I at my context limits? */2741if((leading <= p_context) && (trailing <= p_context))2742break;2743if(match_beginning || match_end) {2744 match_beginning = match_end =0;2745continue;2746}27472748/*2749 * Reduce the number of context lines; reduce both2750 * leading and trailing if they are equal otherwise2751 * just reduce the larger context.2752 */2753if(leading >= trailing) {2754remove_first_line(&preimage);2755remove_first_line(&postimage);2756 pos--;2757 leading--;2758}2759if(trailing > leading) {2760remove_last_line(&preimage);2761remove_last_line(&postimage);2762 trailing--;2763}2764}27652766if(applied_pos >=0) {2767if(new_blank_lines_at_end &&2768 preimage.nr + applied_pos >= img->nr &&2769(ws_rule & WS_BLANK_AT_EOF) &&2770 ws_error_action != nowarn_ws_error) {2771record_ws_error(WS_BLANK_AT_EOF,"+",1,2772 found_new_blank_lines_at_end);2773if(ws_error_action == correct_ws_error) {2774while(new_blank_lines_at_end--)2775remove_last_line(&postimage);2776}2777/*2778 * We would want to prevent write_out_results()2779 * from taking place in apply_patch() that follows2780 * the callchain led us here, which is:2781 * apply_patch->check_patch_list->check_patch->2782 * apply_data->apply_fragments->apply_one_fragment2783 */2784if(ws_error_action == die_on_ws_error)2785 apply =0;2786}27872788if(apply_verbosely && applied_pos != pos) {2789int offset = applied_pos - pos;2790if(apply_in_reverse)2791 offset =0- offset;2792fprintf_ln(stderr,2793Q_("Hunk #%dsucceeded at%d(offset%dline).",2794"Hunk #%dsucceeded at%d(offset%dlines).",2795 offset),2796 nth_fragment, applied_pos +1, offset);2797}27982799/*2800 * Warn if it was necessary to reduce the number2801 * of context lines.2802 */2803if((leading != frag->leading) ||2804(trailing != frag->trailing))2805fprintf_ln(stderr,_("Context reduced to (%ld/%ld)"2806" to apply fragment at%d"),2807 leading, trailing, applied_pos+1);2808update_image(img, applied_pos, &preimage, &postimage);2809}else{2810if(apply_verbosely)2811error(_("while searching for:\n%.*s"),2812(int)(old - oldlines), oldlines);2813}28142815free(oldlines);2816strbuf_release(&newlines);2817free(preimage.line_allocated);2818free(postimage.line_allocated);28192820return(applied_pos <0);2821}28222823static intapply_binary_fragment(struct image *img,struct patch *patch)2824{2825struct fragment *fragment = patch->fragments;2826unsigned long len;2827void*dst;28282829if(!fragment)2830returnerror(_("missing binary patch data for '%s'"),2831 patch->new_name ?2832 patch->new_name :2833 patch->old_name);28342835/* Binary patch is irreversible without the optional second hunk */2836if(apply_in_reverse) {2837if(!fragment->next)2838returnerror("cannot reverse-apply a binary patch "2839"without the reverse hunk to '%s'",2840 patch->new_name2841? patch->new_name : patch->old_name);2842 fragment = fragment->next;2843}2844switch(fragment->binary_patch_method) {2845case BINARY_DELTA_DEFLATED:2846 dst =patch_delta(img->buf, img->len, fragment->patch,2847 fragment->size, &len);2848if(!dst)2849return-1;2850clear_image(img);2851 img->buf = dst;2852 img->len = len;2853return0;2854case BINARY_LITERAL_DEFLATED:2855clear_image(img);2856 img->len = fragment->size;2857 img->buf =xmalloc(img->len+1);2858memcpy(img->buf, fragment->patch, img->len);2859 img->buf[img->len] ='\0';2860return0;2861}2862return-1;2863}28642865/*2866 * Replace "img" with the result of applying the binary patch.2867 * The binary patch data itself in patch->fragment is still kept2868 * but the preimage prepared by the caller in "img" is freed here2869 * or in the helper function apply_binary_fragment() this calls.2870 */2871static intapply_binary(struct image *img,struct patch *patch)2872{2873const char*name = patch->old_name ? patch->old_name : patch->new_name;2874unsigned char sha1[20];28752876/*2877 * For safety, we require patch index line to contain2878 * full 40-byte textual SHA1 for old and new, at least for now.2879 */2880if(strlen(patch->old_sha1_prefix) !=40||2881strlen(patch->new_sha1_prefix) !=40||2882get_sha1_hex(patch->old_sha1_prefix, sha1) ||2883get_sha1_hex(patch->new_sha1_prefix, sha1))2884returnerror("cannot apply binary patch to '%s' "2885"without full index line", name);28862887if(patch->old_name) {2888/*2889 * See if the old one matches what the patch2890 * applies to.2891 */2892hash_sha1_file(img->buf, img->len, blob_type, sha1);2893if(strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))2894returnerror("the patch applies to '%s' (%s), "2895"which does not match the "2896"current contents.",2897 name,sha1_to_hex(sha1));2898}2899else{2900/* Otherwise, the old one must be empty. */2901if(img->len)2902returnerror("the patch applies to an empty "2903"'%s' but it is not empty", name);2904}29052906get_sha1_hex(patch->new_sha1_prefix, sha1);2907if(is_null_sha1(sha1)) {2908clear_image(img);2909return0;/* deletion patch */2910}29112912if(has_sha1_file(sha1)) {2913/* We already have the postimage */2914enum object_type type;2915unsigned long size;2916char*result;29172918 result =read_sha1_file(sha1, &type, &size);2919if(!result)2920returnerror("the necessary postimage%sfor "2921"'%s' cannot be read",2922 patch->new_sha1_prefix, name);2923clear_image(img);2924 img->buf = result;2925 img->len = size;2926}else{2927/*2928 * We have verified buf matches the preimage;2929 * apply the patch data to it, which is stored2930 * in the patch->fragments->{patch,size}.2931 */2932if(apply_binary_fragment(img, patch))2933returnerror(_("binary patch does not apply to '%s'"),2934 name);29352936/* verify that the result matches */2937hash_sha1_file(img->buf, img->len, blob_type, sha1);2938if(strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))2939returnerror(_("binary patch to '%s' creates incorrect result (expecting%s, got%s)"),2940 name, patch->new_sha1_prefix,sha1_to_hex(sha1));2941}29422943return0;2944}29452946static intapply_fragments(struct image *img,struct patch *patch)2947{2948struct fragment *frag = patch->fragments;2949const char*name = patch->old_name ? patch->old_name : patch->new_name;2950unsigned ws_rule = patch->ws_rule;2951unsigned inaccurate_eof = patch->inaccurate_eof;2952int nth =0;29532954if(patch->is_binary)2955returnapply_binary(img, patch);29562957while(frag) {2958 nth++;2959if(apply_one_fragment(img, frag, inaccurate_eof, ws_rule, nth)) {2960error(_("patch failed:%s:%ld"), name, frag->oldpos);2961if(!apply_with_reject)2962return-1;2963 frag->rejected =1;2964}2965 frag = frag->next;2966}2967return0;2968}29692970static intread_blob_object(struct strbuf *buf,const unsigned char*sha1,unsigned mode)2971{2972if(S_ISGITLINK(mode)) {2973strbuf_grow(buf,100);2974strbuf_addf(buf,"Subproject commit%s\n",sha1_to_hex(sha1));2975}else{2976enum object_type type;2977unsigned long sz;2978char*result;29792980 result =read_sha1_file(sha1, &type, &sz);2981if(!result)2982return-1;2983/* XXX read_sha1_file NUL-terminates */2984strbuf_attach(buf, result, sz, sz +1);2985}2986return0;2987}29882989static intread_file_or_gitlink(struct cache_entry *ce,struct strbuf *buf)2990{2991if(!ce)2992return0;2993returnread_blob_object(buf, ce->sha1, ce->ce_mode);2994}29952996static struct patch *in_fn_table(const char*name)2997{2998struct string_list_item *item;29993000if(name == NULL)3001return NULL;30023003 item =string_list_lookup(&fn_table, name);3004if(item != NULL)3005return(struct patch *)item->util;30063007return NULL;3008}30093010/*3011 * item->util in the filename table records the status of the path.3012 * Usually it points at a patch (whose result records the contents3013 * of it after applying it), but it could be PATH_WAS_DELETED for a3014 * path that a previously applied patch has already removed, or3015 * PATH_TO_BE_DELETED for a path that a later patch would remove.3016 *3017 * The latter is needed to deal with a case where two paths A and B3018 * are swapped by first renaming A to B and then renaming B to A;3019 * moving A to B should not be prevented due to presense of B as we3020 * will remove it in a later patch.3021 */3022#define PATH_TO_BE_DELETED ((struct patch *) -2)3023#define PATH_WAS_DELETED ((struct patch *) -1)30243025static intto_be_deleted(struct patch *patch)3026{3027return patch == PATH_TO_BE_DELETED;3028}30293030static intwas_deleted(struct patch *patch)3031{3032return patch == PATH_WAS_DELETED;3033}30343035static voidadd_to_fn_table(struct patch *patch)3036{3037struct string_list_item *item;30383039/*3040 * Always add new_name unless patch is a deletion3041 * This should cover the cases for normal diffs,3042 * file creations and copies3043 */3044if(patch->new_name != NULL) {3045 item =string_list_insert(&fn_table, patch->new_name);3046 item->util = patch;3047}30483049/*3050 * store a failure on rename/deletion cases because3051 * later chunks shouldn't patch old names3052 */3053if((patch->new_name == NULL) || (patch->is_rename)) {3054 item =string_list_insert(&fn_table, patch->old_name);3055 item->util = PATH_WAS_DELETED;3056}3057}30583059static voidprepare_fn_table(struct patch *patch)3060{3061/*3062 * store information about incoming file deletion3063 */3064while(patch) {3065if((patch->new_name == NULL) || (patch->is_rename)) {3066struct string_list_item *item;3067 item =string_list_insert(&fn_table, patch->old_name);3068 item->util = PATH_TO_BE_DELETED;3069}3070 patch = patch->next;3071}3072}30733074static intcheckout_target(struct cache_entry *ce,struct stat *st)3075{3076struct checkout costate;30773078memset(&costate,0,sizeof(costate));3079 costate.base_dir ="";3080 costate.refresh_cache =1;3081if(checkout_entry(ce, &costate, NULL) ||lstat(ce->name, st))3082returnerror(_("cannot checkout%s"), ce->name);3083return0;3084}30853086static struct patch *previous_patch(struct patch *patch,int*gone)3087{3088struct patch *previous;30893090*gone =0;3091if(patch->is_copy || patch->is_rename)3092return NULL;/* "git" patches do not depend on the order */30933094 previous =in_fn_table(patch->old_name);3095if(!previous)3096return NULL;30973098if(to_be_deleted(previous))3099return NULL;/* the deletion hasn't happened yet */31003101if(was_deleted(previous))3102*gone =1;31033104return previous;3105}31063107static intverify_index_match(struct cache_entry *ce,struct stat *st)3108{3109if(S_ISGITLINK(ce->ce_mode)) {3110if(!S_ISDIR(st->st_mode))3111return-1;3112return0;3113}3114returnce_match_stat(ce, st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);3115}31163117#define SUBMODULE_PATCH_WITHOUT_INDEX 131183119static intload_patch_target(struct strbuf *buf,3120struct cache_entry *ce,3121struct stat *st,3122const char*name,3123unsigned expected_mode)3124{3125if(cached) {3126if(read_file_or_gitlink(ce, buf))3127returnerror(_("read of%sfailed"), name);3128}else if(name) {3129if(S_ISGITLINK(expected_mode)) {3130if(ce)3131returnread_file_or_gitlink(ce, buf);3132else3133return SUBMODULE_PATCH_WITHOUT_INDEX;3134}else{3135if(read_old_data(st, name, buf))3136returnerror(_("read of%sfailed"), name);3137}3138}3139return0;3140}31413142/*3143 * We are about to apply "patch"; populate the "image" with the3144 * current version we have, from the working tree or from the index,3145 * depending on the situation e.g. --cached/--index. If we are3146 * applying a non-git patch that incrementally updates the tree,3147 * we read from the result of a previous diff.3148 */3149static intload_preimage(struct image *image,3150struct patch *patch,struct stat *st,struct cache_entry *ce)3151{3152struct strbuf buf = STRBUF_INIT;3153size_t len;3154char*img;3155struct patch *previous;3156int status;31573158 previous =previous_patch(patch, &status);3159if(status)3160returnerror(_("path%shas been renamed/deleted"),3161 patch->old_name);3162if(previous) {3163/* We have a patched copy in memory; use that. */3164strbuf_add(&buf, previous->result, previous->resultsize);3165}else{3166 status =load_patch_target(&buf, ce, st,3167 patch->old_name, patch->old_mode);3168if(status <0)3169return status;3170else if(status == SUBMODULE_PATCH_WITHOUT_INDEX) {3171/*3172 * There is no way to apply subproject3173 * patch without looking at the index.3174 * NEEDSWORK: shouldn't this be flagged3175 * as an error???3176 */3177free_fragment_list(patch->fragments);3178 patch->fragments = NULL;3179}else if(status) {3180returnerror(_("read of%sfailed"), patch->old_name);3181}3182}31833184 img =strbuf_detach(&buf, &len);3185prepare_image(image, img, len, !patch->is_binary);3186return0;3187}31883189static intthree_way_merge(struct image *image,3190char*path,3191const unsigned char*base,3192const unsigned char*ours,3193const unsigned char*theirs)3194{3195 mmfile_t base_file, our_file, their_file;3196 mmbuffer_t result = { NULL };3197int status;31983199read_mmblob(&base_file, base);3200read_mmblob(&our_file, ours);3201read_mmblob(&their_file, theirs);3202 status =ll_merge(&result, path,3203&base_file,"base",3204&our_file,"ours",3205&their_file,"theirs", NULL);3206free(base_file.ptr);3207free(our_file.ptr);3208free(their_file.ptr);3209if(status <0|| !result.ptr) {3210free(result.ptr);3211return-1;3212}3213clear_image(image);3214 image->buf = result.ptr;3215 image->len = result.size;32163217return status;3218}32193220/*3221 * When directly falling back to add/add three-way merge, we read from3222 * the current contents of the new_name. In no cases other than that3223 * this function will be called.3224 */3225static intload_current(struct image *image,struct patch *patch)3226{3227struct strbuf buf = STRBUF_INIT;3228int status, pos;3229size_t len;3230char*img;3231struct stat st;3232struct cache_entry *ce;3233char*name = patch->new_name;3234unsigned mode = patch->new_mode;32353236if(!patch->is_new)3237die("BUG: patch to%sis not a creation", patch->old_name);32383239 pos =cache_name_pos(name,strlen(name));3240if(pos <0)3241returnerror(_("%s: does not exist in index"), name);3242 ce = active_cache[pos];3243if(lstat(name, &st)) {3244if(errno != ENOENT)3245returnerror(_("%s:%s"), name,strerror(errno));3246if(checkout_target(ce, &st))3247return-1;3248}3249if(verify_index_match(ce, &st))3250returnerror(_("%s: does not match index"), name);32513252 status =load_patch_target(&buf, ce, &st, name, mode);3253if(status <0)3254return status;3255else if(status)3256return-1;3257 img =strbuf_detach(&buf, &len);3258prepare_image(image, img, len, !patch->is_binary);3259return0;3260}32613262static inttry_threeway(struct image *image,struct patch *patch,3263struct stat *st,struct cache_entry *ce)3264{3265unsigned char pre_sha1[20], post_sha1[20], our_sha1[20];3266struct strbuf buf = STRBUF_INIT;3267size_t len;3268int status;3269char*img;3270struct image tmp_image;32713272/* No point falling back to 3-way merge in these cases */3273if(patch->is_delete ||3274S_ISGITLINK(patch->old_mode) ||S_ISGITLINK(patch->new_mode))3275return-1;32763277/* Preimage the patch was prepared for */3278if(patch->is_new)3279write_sha1_file("",0, blob_type, pre_sha1);3280else if(get_sha1(patch->old_sha1_prefix, pre_sha1) ||3281read_blob_object(&buf, pre_sha1, patch->old_mode))3282returnerror("repository lacks the necessary blob to fall back on 3-way merge.");32833284fprintf(stderr,"Falling back to three-way merge...\n");32853286 img =strbuf_detach(&buf, &len);3287prepare_image(&tmp_image, img, len,1);3288/* Apply the patch to get the post image */3289if(apply_fragments(&tmp_image, patch) <0) {3290clear_image(&tmp_image);3291return-1;3292}3293/* post_sha1[] is theirs */3294write_sha1_file(tmp_image.buf, tmp_image.len, blob_type, post_sha1);3295clear_image(&tmp_image);32963297/* our_sha1[] is ours */3298if(patch->is_new) {3299if(load_current(&tmp_image, patch))3300returnerror("cannot read the current contents of '%s'",3301 patch->new_name);3302}else{3303if(load_preimage(&tmp_image, patch, st, ce))3304returnerror("cannot read the current contents of '%s'",3305 patch->old_name);3306}3307write_sha1_file(tmp_image.buf, tmp_image.len, blob_type, our_sha1);3308clear_image(&tmp_image);33093310/* in-core three-way merge between post and our using pre as base */3311 status =three_way_merge(image, patch->new_name,3312 pre_sha1, our_sha1, post_sha1);3313if(status <0) {3314fprintf(stderr,"Failed to fall back on three-way merge...\n");3315return status;3316}33173318if(status) {3319 patch->conflicted_threeway =1;3320if(patch->is_new)3321hashclr(patch->threeway_stage[0]);3322else3323hashcpy(patch->threeway_stage[0], pre_sha1);3324hashcpy(patch->threeway_stage[1], our_sha1);3325hashcpy(patch->threeway_stage[2], post_sha1);3326fprintf(stderr,"Applied patch to '%s' with conflicts.\n", patch->new_name);3327}else{3328fprintf(stderr,"Applied patch to '%s' cleanly.\n", patch->new_name);3329}3330return0;3331}33323333static intapply_data(struct patch *patch,struct stat *st,struct cache_entry *ce)3334{3335struct image image;33363337if(load_preimage(&image, patch, st, ce) <0)3338return-1;33393340if(patch->direct_to_threeway ||3341apply_fragments(&image, patch) <0) {3342/* Note: with --reject, apply_fragments() returns 0 */3343if(!threeway ||try_threeway(&image, patch, st, ce) <0)3344return-1;3345}3346 patch->result = image.buf;3347 patch->resultsize = image.len;3348add_to_fn_table(patch);3349free(image.line_allocated);33503351if(0< patch->is_delete && patch->resultsize)3352returnerror(_("removal patch leaves file contents"));33533354return0;3355}33563357/*3358 * If "patch" that we are looking at modifies or deletes what we have,3359 * we would want it not to lose any local modification we have, either3360 * in the working tree or in the index.3361 *3362 * This also decides if a non-git patch is a creation patch or a3363 * modification to an existing empty file. We do not check the state3364 * of the current tree for a creation patch in this function; the caller3365 * check_patch() separately makes sure (and errors out otherwise) that3366 * the path the patch creates does not exist in the current tree.3367 */3368static intcheck_preimage(struct patch *patch,struct cache_entry **ce,struct stat *st)3369{3370const char*old_name = patch->old_name;3371struct patch *previous = NULL;3372int stat_ret =0, status;3373unsigned st_mode =0;33743375if(!old_name)3376return0;33773378assert(patch->is_new <=0);3379 previous =previous_patch(patch, &status);33803381if(status)3382returnerror(_("path%shas been renamed/deleted"), old_name);3383if(previous) {3384 st_mode = previous->new_mode;3385}else if(!cached) {3386 stat_ret =lstat(old_name, st);3387if(stat_ret && errno != ENOENT)3388returnerror(_("%s:%s"), old_name,strerror(errno));3389}33903391if(check_index && !previous) {3392int pos =cache_name_pos(old_name,strlen(old_name));3393if(pos <0) {3394if(patch->is_new <0)3395goto is_new;3396returnerror(_("%s: does not exist in index"), old_name);3397}3398*ce = active_cache[pos];3399if(stat_ret <0) {3400if(checkout_target(*ce, st))3401return-1;3402}3403if(!cached &&verify_index_match(*ce, st))3404returnerror(_("%s: does not match index"), old_name);3405if(cached)3406 st_mode = (*ce)->ce_mode;3407}else if(stat_ret <0) {3408if(patch->is_new <0)3409goto is_new;3410returnerror(_("%s:%s"), old_name,strerror(errno));3411}34123413if(!cached && !previous)3414 st_mode =ce_mode_from_stat(*ce, st->st_mode);34153416if(patch->is_new <0)3417 patch->is_new =0;3418if(!patch->old_mode)3419 patch->old_mode = st_mode;3420if((st_mode ^ patch->old_mode) & S_IFMT)3421returnerror(_("%s: wrong type"), old_name);3422if(st_mode != patch->old_mode)3423warning(_("%shas type%o, expected%o"),3424 old_name, st_mode, patch->old_mode);3425if(!patch->new_mode && !patch->is_delete)3426 patch->new_mode = st_mode;3427return0;34283429 is_new:3430 patch->is_new =1;3431 patch->is_delete =0;3432free(patch->old_name);3433 patch->old_name = NULL;3434return0;3435}343634373438#define EXISTS_IN_INDEX 13439#define EXISTS_IN_WORKTREE 234403441static intcheck_to_create(const char*new_name,int ok_if_exists)3442{3443struct stat nst;34443445if(check_index &&3446cache_name_pos(new_name,strlen(new_name)) >=0&&3447!ok_if_exists)3448return EXISTS_IN_INDEX;3449if(cached)3450return0;34513452if(!lstat(new_name, &nst)) {3453if(S_ISDIR(nst.st_mode) || ok_if_exists)3454return0;3455/*3456 * A leading component of new_name might be a symlink3457 * that is going to be removed with this patch, but3458 * still pointing at somewhere that has the path.3459 * In such a case, path "new_name" does not exist as3460 * far as git is concerned.3461 */3462if(has_symlink_leading_path(new_name,strlen(new_name)))3463return0;34643465return EXISTS_IN_WORKTREE;3466}else if((errno != ENOENT) && (errno != ENOTDIR)) {3467returnerror("%s:%s", new_name,strerror(errno));3468}3469return0;3470}34713472/*3473 * Check and apply the patch in-core; leave the result in patch->result3474 * for the caller to write it out to the final destination.3475 */3476static intcheck_patch(struct patch *patch)3477{3478struct stat st;3479const char*old_name = patch->old_name;3480const char*new_name = patch->new_name;3481const char*name = old_name ? old_name : new_name;3482struct cache_entry *ce = NULL;3483struct patch *tpatch;3484int ok_if_exists;3485int status;34863487 patch->rejected =1;/* we will drop this after we succeed */34883489 status =check_preimage(patch, &ce, &st);3490if(status)3491return status;3492 old_name = patch->old_name;34933494/*3495 * A type-change diff is always split into a patch to delete3496 * old, immediately followed by a patch to create new (see3497 * diff.c::run_diff()); in such a case it is Ok that the entry3498 * to be deleted by the previous patch is still in the working3499 * tree and in the index.3500 *3501 * A patch to swap-rename between A and B would first rename A3502 * to B and then rename B to A. While applying the first one,3503 * the presense of B should not stop A from getting renamed to3504 * B; ask to_be_deleted() about the later rename. Removal of3505 * B and rename from A to B is handled the same way by asking3506 * was_deleted().3507 */3508if((tpatch =in_fn_table(new_name)) &&3509(was_deleted(tpatch) ||to_be_deleted(tpatch)))3510 ok_if_exists =1;3511else3512 ok_if_exists =0;35133514if(new_name &&3515((0< patch->is_new) | (0< patch->is_rename) | patch->is_copy)) {3516int err =check_to_create(new_name, ok_if_exists);35173518if(err && threeway) {3519 patch->direct_to_threeway =1;3520}else switch(err) {3521case0:3522break;/* happy */3523case EXISTS_IN_INDEX:3524returnerror(_("%s: already exists in index"), new_name);3525break;3526case EXISTS_IN_WORKTREE:3527returnerror(_("%s: already exists in working directory"),3528 new_name);3529default:3530return err;3531}35323533if(!patch->new_mode) {3534if(0< patch->is_new)3535 patch->new_mode = S_IFREG |0644;3536else3537 patch->new_mode = patch->old_mode;3538}3539}35403541if(new_name && old_name) {3542int same = !strcmp(old_name, new_name);3543if(!patch->new_mode)3544 patch->new_mode = patch->old_mode;3545if((patch->old_mode ^ patch->new_mode) & S_IFMT) {3546if(same)3547returnerror(_("new mode (%o) of%sdoes not "3548"match old mode (%o)"),3549 patch->new_mode, new_name,3550 patch->old_mode);3551else3552returnerror(_("new mode (%o) of%sdoes not "3553"match old mode (%o) of%s"),3554 patch->new_mode, new_name,3555 patch->old_mode, old_name);3556}3557}35583559if(apply_data(patch, &st, ce) <0)3560returnerror(_("%s: patch does not apply"), name);3561 patch->rejected =0;3562return0;3563}35643565static intcheck_patch_list(struct patch *patch)3566{3567int err =0;35683569prepare_fn_table(patch);3570while(patch) {3571if(apply_verbosely)3572say_patch_name(stderr,3573_("Checking patch%s..."), patch);3574 err |=check_patch(patch);3575 patch = patch->next;3576}3577return err;3578}35793580/* This function tries to read the sha1 from the current index */3581static intget_current_sha1(const char*path,unsigned char*sha1)3582{3583int pos;35843585if(read_cache() <0)3586return-1;3587 pos =cache_name_pos(path,strlen(path));3588if(pos <0)3589return-1;3590hashcpy(sha1, active_cache[pos]->sha1);3591return0;3592}35933594/* Build an index that contains the just the files needed for a 3way merge */3595static voidbuild_fake_ancestor(struct patch *list,const char*filename)3596{3597struct patch *patch;3598struct index_state result = { NULL };3599int fd;36003601/* Once we start supporting the reverse patch, it may be3602 * worth showing the new sha1 prefix, but until then...3603 */3604for(patch = list; patch; patch = patch->next) {3605const unsigned char*sha1_ptr;3606unsigned char sha1[20];3607struct cache_entry *ce;3608const char*name;36093610 name = patch->old_name ? patch->old_name : patch->new_name;3611if(0< patch->is_new)3612continue;3613else if(get_sha1_blob(patch->old_sha1_prefix, sha1))3614/* git diff has no index line for mode/type changes */3615if(!patch->lines_added && !patch->lines_deleted) {3616if(get_current_sha1(patch->old_name, sha1))3617die("mode change for%s, which is not "3618"in current HEAD", name);3619 sha1_ptr = sha1;3620}else3621die("sha1 information is lacking or useless "3622"(%s).", name);3623else3624 sha1_ptr = sha1;36253626 ce =make_cache_entry(patch->old_mode, sha1_ptr, name,0,0);3627if(!ce)3628die(_("make_cache_entry failed for path '%s'"), name);3629if(add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))3630die("Could not add%sto temporary index", name);3631}36323633 fd =open(filename, O_WRONLY | O_CREAT,0666);3634if(fd <0||write_index(&result, fd) ||close(fd))3635die("Could not write temporary index to%s", filename);36363637discard_index(&result);3638}36393640static voidstat_patch_list(struct patch *patch)3641{3642int files, adds, dels;36433644for(files = adds = dels =0; patch ; patch = patch->next) {3645 files++;3646 adds += patch->lines_added;3647 dels += patch->lines_deleted;3648show_stats(patch);3649}36503651print_stat_summary(stdout, files, adds, dels);3652}36533654static voidnumstat_patch_list(struct patch *patch)3655{3656for( ; patch; patch = patch->next) {3657const char*name;3658 name = patch->new_name ? patch->new_name : patch->old_name;3659if(patch->is_binary)3660printf("-\t-\t");3661else3662printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);3663write_name_quoted(name, stdout, line_termination);3664}3665}36663667static voidshow_file_mode_name(const char*newdelete,unsigned int mode,const char*name)3668{3669if(mode)3670printf("%smode%06o%s\n", newdelete, mode, name);3671else3672printf("%s %s\n", newdelete, name);3673}36743675static voidshow_mode_change(struct patch *p,int show_name)3676{3677if(p->old_mode && p->new_mode && p->old_mode != p->new_mode) {3678if(show_name)3679printf(" mode change%06o =>%06o%s\n",3680 p->old_mode, p->new_mode, p->new_name);3681else3682printf(" mode change%06o =>%06o\n",3683 p->old_mode, p->new_mode);3684}3685}36863687static voidshow_rename_copy(struct patch *p)3688{3689const char*renamecopy = p->is_rename ?"rename":"copy";3690const char*old, *new;36913692/* Find common prefix */3693 old = p->old_name;3694new= p->new_name;3695while(1) {3696const char*slash_old, *slash_new;3697 slash_old =strchr(old,'/');3698 slash_new =strchr(new,'/');3699if(!slash_old ||3700!slash_new ||3701 slash_old - old != slash_new -new||3702memcmp(old,new, slash_new -new))3703break;3704 old = slash_old +1;3705new= slash_new +1;3706}3707/* p->old_name thru old is the common prefix, and old and new3708 * through the end of names are renames3709 */3710if(old != p->old_name)3711printf("%s%.*s{%s=>%s} (%d%%)\n", renamecopy,3712(int)(old - p->old_name), p->old_name,3713 old,new, p->score);3714else3715printf("%s %s=>%s(%d%%)\n", renamecopy,3716 p->old_name, p->new_name, p->score);3717show_mode_change(p,0);3718}37193720static voidsummary_patch_list(struct patch *patch)3721{3722struct patch *p;37233724for(p = patch; p; p = p->next) {3725if(p->is_new)3726show_file_mode_name("create", p->new_mode, p->new_name);3727else if(p->is_delete)3728show_file_mode_name("delete", p->old_mode, p->old_name);3729else{3730if(p->is_rename || p->is_copy)3731show_rename_copy(p);3732else{3733if(p->score) {3734printf(" rewrite%s(%d%%)\n",3735 p->new_name, p->score);3736show_mode_change(p,0);3737}3738else3739show_mode_change(p,1);3740}3741}3742}3743}37443745static voidpatch_stats(struct patch *patch)3746{3747int lines = patch->lines_added + patch->lines_deleted;37483749if(lines > max_change)3750 max_change = lines;3751if(patch->old_name) {3752int len =quote_c_style(patch->old_name, NULL, NULL,0);3753if(!len)3754 len =strlen(patch->old_name);3755if(len > max_len)3756 max_len = len;3757}3758if(patch->new_name) {3759int len =quote_c_style(patch->new_name, NULL, NULL,0);3760if(!len)3761 len =strlen(patch->new_name);3762if(len > max_len)3763 max_len = len;3764}3765}37663767static voidremove_file(struct patch *patch,int rmdir_empty)3768{3769if(update_index) {3770if(remove_file_from_cache(patch->old_name) <0)3771die(_("unable to remove%sfrom index"), patch->old_name);3772}3773if(!cached) {3774if(!remove_or_warn(patch->old_mode, patch->old_name) && rmdir_empty) {3775remove_path(patch->old_name);3776}3777}3778}37793780static voidadd_index_file(const char*path,unsigned mode,void*buf,unsigned long size)3781{3782struct stat st;3783struct cache_entry *ce;3784int namelen =strlen(path);3785unsigned ce_size =cache_entry_size(namelen);37863787if(!update_index)3788return;37893790 ce =xcalloc(1, ce_size);3791memcpy(ce->name, path, namelen);3792 ce->ce_mode =create_ce_mode(mode);3793 ce->ce_flags =create_ce_flags(0);3794 ce->ce_namelen = namelen;3795if(S_ISGITLINK(mode)) {3796const char*s = buf;37973798if(get_sha1_hex(s +strlen("Subproject commit "), ce->sha1))3799die(_("corrupt patch for subproject%s"), path);3800}else{3801if(!cached) {3802if(lstat(path, &st) <0)3803die_errno(_("unable to stat newly created file '%s'"),3804 path);3805fill_stat_cache_info(ce, &st);3806}3807if(write_sha1_file(buf, size, blob_type, ce->sha1) <0)3808die(_("unable to create backing store for newly created file%s"), path);3809}3810if(add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) <0)3811die(_("unable to add cache entry for%s"), path);3812}38133814static inttry_create_file(const char*path,unsigned int mode,const char*buf,unsigned long size)3815{3816int fd;3817struct strbuf nbuf = STRBUF_INIT;38183819if(S_ISGITLINK(mode)) {3820struct stat st;3821if(!lstat(path, &st) &&S_ISDIR(st.st_mode))3822return0;3823returnmkdir(path,0777);3824}38253826if(has_symlinks &&S_ISLNK(mode))3827/* Although buf:size is counted string, it also is NUL3828 * terminated.3829 */3830returnsymlink(buf, path);38313832 fd =open(path, O_CREAT | O_EXCL | O_WRONLY, (mode &0100) ?0777:0666);3833if(fd <0)3834return-1;38353836if(convert_to_working_tree(path, buf, size, &nbuf)) {3837 size = nbuf.len;3838 buf = nbuf.buf;3839}3840write_or_die(fd, buf, size);3841strbuf_release(&nbuf);38423843if(close(fd) <0)3844die_errno(_("closing file '%s'"), path);3845return0;3846}38473848/*3849 * We optimistically assume that the directories exist,3850 * which is true 99% of the time anyway. If they don't,3851 * we create them and try again.3852 */3853static voidcreate_one_file(char*path,unsigned mode,const char*buf,unsigned long size)3854{3855if(cached)3856return;3857if(!try_create_file(path, mode, buf, size))3858return;38593860if(errno == ENOENT) {3861if(safe_create_leading_directories(path))3862return;3863if(!try_create_file(path, mode, buf, size))3864return;3865}38663867if(errno == EEXIST || errno == EACCES) {3868/* We may be trying to create a file where a directory3869 * used to be.3870 */3871struct stat st;3872if(!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))3873 errno = EEXIST;3874}38753876if(errno == EEXIST) {3877unsigned int nr =getpid();38783879for(;;) {3880char newpath[PATH_MAX];3881mksnpath(newpath,sizeof(newpath),"%s~%u", path, nr);3882if(!try_create_file(newpath, mode, buf, size)) {3883if(!rename(newpath, path))3884return;3885unlink_or_warn(newpath);3886break;3887}3888if(errno != EEXIST)3889break;3890++nr;3891}3892}3893die_errno(_("unable to write file '%s' mode%o"), path, mode);3894}38953896static voidadd_conflicted_stages_file(struct patch *patch)3897{3898int stage, namelen;3899unsigned ce_size, mode;3900struct cache_entry *ce;39013902if(!update_index)3903return;3904 namelen =strlen(patch->new_name);3905 ce_size =cache_entry_size(namelen);3906 mode = patch->new_mode ? patch->new_mode : (S_IFREG |0644);39073908remove_file_from_cache(patch->new_name);3909for(stage =1; stage <4; stage++) {3910if(is_null_sha1(patch->threeway_stage[stage -1]))3911continue;3912 ce =xcalloc(1, ce_size);3913memcpy(ce->name, patch->new_name, namelen);3914 ce->ce_mode =create_ce_mode(mode);3915 ce->ce_flags =create_ce_flags(stage);3916 ce->ce_namelen = namelen;3917hashcpy(ce->sha1, patch->threeway_stage[stage -1]);3918if(add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) <0)3919die(_("unable to add cache entry for%s"), patch->new_name);3920}3921}39223923static voidcreate_file(struct patch *patch)3924{3925char*path = patch->new_name;3926unsigned mode = patch->new_mode;3927unsigned long size = patch->resultsize;3928char*buf = patch->result;39293930if(!mode)3931 mode = S_IFREG |0644;3932create_one_file(path, mode, buf, size);39333934if(patch->conflicted_threeway)3935add_conflicted_stages_file(patch);3936else3937add_index_file(path, mode, buf, size);3938}39393940/* phase zero is to remove, phase one is to create */3941static voidwrite_out_one_result(struct patch *patch,int phase)3942{3943if(patch->is_delete >0) {3944if(phase ==0)3945remove_file(patch,1);3946return;3947}3948if(patch->is_new >0|| patch->is_copy) {3949if(phase ==1)3950create_file(patch);3951return;3952}3953/*3954 * Rename or modification boils down to the same3955 * thing: remove the old, write the new3956 */3957if(phase ==0)3958remove_file(patch, patch->is_rename);3959if(phase ==1)3960create_file(patch);3961}39623963static intwrite_out_one_reject(struct patch *patch)3964{3965FILE*rej;3966char namebuf[PATH_MAX];3967struct fragment *frag;3968int cnt =0;3969struct strbuf sb = STRBUF_INIT;39703971for(cnt =0, frag = patch->fragments; frag; frag = frag->next) {3972if(!frag->rejected)3973continue;3974 cnt++;3975}39763977if(!cnt) {3978if(apply_verbosely)3979say_patch_name(stderr,3980_("Applied patch%scleanly."), patch);3981return0;3982}39833984/* This should not happen, because a removal patch that leaves3985 * contents are marked "rejected" at the patch level.3986 */3987if(!patch->new_name)3988die(_("internal error"));39893990/* Say this even without --verbose */3991strbuf_addf(&sb,Q_("Applying patch %%swith%dreject...",3992"Applying patch %%swith%drejects...",3993 cnt),3994 cnt);3995say_patch_name(stderr, sb.buf, patch);3996strbuf_release(&sb);39973998 cnt =strlen(patch->new_name);3999if(ARRAY_SIZE(namebuf) <= cnt +5) {4000 cnt =ARRAY_SIZE(namebuf) -5;4001warning(_("truncating .rej filename to %.*s.rej"),4002 cnt -1, patch->new_name);4003}4004memcpy(namebuf, patch->new_name, cnt);4005memcpy(namebuf + cnt,".rej",5);40064007 rej =fopen(namebuf,"w");4008if(!rej)4009returnerror(_("cannot open%s:%s"), namebuf,strerror(errno));40104011/* Normal git tools never deal with .rej, so do not pretend4012 * this is a git patch by saying --git nor give extended4013 * headers. While at it, maybe please "kompare" that wants4014 * the trailing TAB and some garbage at the end of line ;-).4015 */4016fprintf(rej,"diff a/%sb/%s\t(rejected hunks)\n",4017 patch->new_name, patch->new_name);4018for(cnt =1, frag = patch->fragments;4019 frag;4020 cnt++, frag = frag->next) {4021if(!frag->rejected) {4022fprintf_ln(stderr,_("Hunk #%dapplied cleanly."), cnt);4023continue;4024}4025fprintf_ln(stderr,_("Rejected hunk #%d."), cnt);4026fprintf(rej,"%.*s", frag->size, frag->patch);4027if(frag->patch[frag->size-1] !='\n')4028fputc('\n', rej);4029}4030fclose(rej);4031return-1;4032}40334034static intwrite_out_results(struct patch *list)4035{4036int phase;4037int errs =0;4038struct patch *l;4039struct string_list cpath = STRING_LIST_INIT_DUP;40404041for(phase =0; phase <2; phase++) {4042 l = list;4043while(l) {4044if(l->rejected)4045 errs =1;4046else{4047write_out_one_result(l, phase);4048if(phase ==1) {4049if(write_out_one_reject(l))4050 errs =1;4051if(l->conflicted_threeway) {4052string_list_append(&cpath, l->new_name);4053 errs =1;4054}4055}4056}4057 l = l->next;4058}4059}40604061if(cpath.nr) {4062struct string_list_item *item;40634064sort_string_list(&cpath);4065for_each_string_list_item(item, &cpath)4066fprintf(stderr,"U%s\n", item->string);4067string_list_clear(&cpath,0);40684069rerere(0);4070}40714072return errs;4073}40744075static struct lock_file lock_file;40764077static struct string_list limit_by_name;4078static int has_include;4079static voidadd_name_limit(const char*name,int exclude)4080{4081struct string_list_item *it;40824083 it =string_list_append(&limit_by_name, name);4084 it->util = exclude ? NULL : (void*)1;4085}40864087static intuse_patch(struct patch *p)4088{4089const char*pathname = p->new_name ? p->new_name : p->old_name;4090int i;40914092/* Paths outside are not touched regardless of "--include" */4093if(0< prefix_length) {4094int pathlen =strlen(pathname);4095if(pathlen <= prefix_length ||4096memcmp(prefix, pathname, prefix_length))4097return0;4098}40994100/* See if it matches any of exclude/include rule */4101for(i =0; i < limit_by_name.nr; i++) {4102struct string_list_item *it = &limit_by_name.items[i];4103if(!fnmatch(it->string, pathname,0))4104return(it->util != NULL);4105}41064107/*4108 * If we had any include, a path that does not match any rule is4109 * not used. Otherwise, we saw bunch of exclude rules (or none)4110 * and such a path is used.4111 */4112return!has_include;4113}411441154116static voidprefix_one(char**name)4117{4118char*old_name = *name;4119if(!old_name)4120return;4121*name =xstrdup(prefix_filename(prefix, prefix_length, *name));4122free(old_name);4123}41244125static voidprefix_patches(struct patch *p)4126{4127if(!prefix || p->is_toplevel_relative)4128return;4129for( ; p; p = p->next) {4130prefix_one(&p->new_name);4131prefix_one(&p->old_name);4132}4133}41344135#define INACCURATE_EOF (1<<0)4136#define RECOUNT (1<<1)41374138static intapply_patch(int fd,const char*filename,int options)4139{4140size_t offset;4141struct strbuf buf = STRBUF_INIT;/* owns the patch text */4142struct patch *list = NULL, **listp = &list;4143int skipped_patch =0;41444145 patch_input_file = filename;4146read_patch_file(&buf, fd);4147 offset =0;4148while(offset < buf.len) {4149struct patch *patch;4150int nr;41514152 patch =xcalloc(1,sizeof(*patch));4153 patch->inaccurate_eof = !!(options & INACCURATE_EOF);4154 patch->recount = !!(options & RECOUNT);4155 nr =parse_chunk(buf.buf + offset, buf.len - offset, patch);4156if(nr <0)4157break;4158if(apply_in_reverse)4159reverse_patches(patch);4160if(prefix)4161prefix_patches(patch);4162if(use_patch(patch)) {4163patch_stats(patch);4164*listp = patch;4165 listp = &patch->next;4166}4167else{4168free_patch(patch);4169 skipped_patch++;4170}4171 offset += nr;4172}41734174if(!list && !skipped_patch)4175die(_("unrecognized input"));41764177if(whitespace_error && (ws_error_action == die_on_ws_error))4178 apply =0;41794180 update_index = check_index && apply;4181if(update_index && newfd <0)4182 newfd =hold_locked_index(&lock_file,1);41834184if(check_index) {4185if(read_cache() <0)4186die(_("unable to read index file"));4187}41884189if((check || apply) &&4190check_patch_list(list) <0&&4191!apply_with_reject)4192exit(1);41934194if(apply &&write_out_results(list)) {4195if(apply_with_reject)4196exit(1);4197/* with --3way, we still need to write the index out */4198return1;4199}42004201if(fake_ancestor)4202build_fake_ancestor(list, fake_ancestor);42034204if(diffstat)4205stat_patch_list(list);42064207if(numstat)4208numstat_patch_list(list);42094210if(summary)4211summary_patch_list(list);42124213free_patch_list(list);4214strbuf_release(&buf);4215string_list_clear(&fn_table,0);4216return0;4217}42184219static intgit_apply_config(const char*var,const char*value,void*cb)4220{4221if(!strcmp(var,"apply.whitespace"))4222returngit_config_string(&apply_default_whitespace, var, value);4223else if(!strcmp(var,"apply.ignorewhitespace"))4224returngit_config_string(&apply_default_ignorewhitespace, var, value);4225returngit_default_config(var, value, cb);4226}42274228static intoption_parse_exclude(const struct option *opt,4229const char*arg,int unset)4230{4231add_name_limit(arg,1);4232return0;4233}42344235static intoption_parse_include(const struct option *opt,4236const char*arg,int unset)4237{4238add_name_limit(arg,0);4239 has_include =1;4240return0;4241}42424243static intoption_parse_p(const struct option *opt,4244const char*arg,int unset)4245{4246 p_value =atoi(arg);4247 p_value_known =1;4248return0;4249}42504251static intoption_parse_z(const struct option *opt,4252const char*arg,int unset)4253{4254if(unset)4255 line_termination ='\n';4256else4257 line_termination =0;4258return0;4259}42604261static intoption_parse_space_change(const struct option *opt,4262const char*arg,int unset)4263{4264if(unset)4265 ws_ignore_action = ignore_ws_none;4266else4267 ws_ignore_action = ignore_ws_change;4268return0;4269}42704271static intoption_parse_whitespace(const struct option *opt,4272const char*arg,int unset)4273{4274const char**whitespace_option = opt->value;42754276*whitespace_option = arg;4277parse_whitespace_option(arg);4278return0;4279}42804281static intoption_parse_directory(const struct option *opt,4282const char*arg,int unset)4283{4284 root_len =strlen(arg);4285if(root_len && arg[root_len -1] !='/') {4286char*new_root;4287 root = new_root =xmalloc(root_len +2);4288strcpy(new_root, arg);4289strcpy(new_root + root_len++,"/");4290}else4291 root = arg;4292return0;4293}42944295intcmd_apply(int argc,const char**argv,const char*prefix_)4296{4297int i;4298int errs =0;4299int is_not_gitdir = !startup_info->have_repository;4300int force_apply =0;43014302const char*whitespace_option = NULL;43034304struct option builtin_apply_options[] = {4305{ OPTION_CALLBACK,0,"exclude", NULL,N_("path"),4306N_("don't apply changes matching the given path"),43070, option_parse_exclude },4308{ OPTION_CALLBACK,0,"include", NULL,N_("path"),4309N_("apply changes matching the given path"),43100, option_parse_include },4311{ OPTION_CALLBACK,'p', NULL, NULL,N_("num"),4312N_("remove <num> leading slashes from traditional diff paths"),43130, option_parse_p },4314OPT_BOOLEAN(0,"no-add", &no_add,4315N_("ignore additions made by the patch")),4316OPT_BOOLEAN(0,"stat", &diffstat,4317N_("instead of applying the patch, output diffstat for the input")),4318OPT_NOOP_NOARG(0,"allow-binary-replacement"),4319OPT_NOOP_NOARG(0,"binary"),4320OPT_BOOLEAN(0,"numstat", &numstat,4321N_("show number of added and deleted lines in decimal notation")),4322OPT_BOOLEAN(0,"summary", &summary,4323N_("instead of applying the patch, output a summary for the input")),4324OPT_BOOLEAN(0,"check", &check,4325N_("instead of applying the patch, see if the patch is applicable")),4326OPT_BOOLEAN(0,"index", &check_index,4327N_("make sure the patch is applicable to the current index")),4328OPT_BOOLEAN(0,"cached", &cached,4329N_("apply a patch without touching the working tree")),4330OPT_BOOLEAN(0,"apply", &force_apply,4331N_("also apply the patch (use with --stat/--summary/--check)")),4332OPT_BOOL('3',"3way", &threeway,4333N_("attempt three-way merge if a patch does not apply")),4334OPT_FILENAME(0,"build-fake-ancestor", &fake_ancestor,4335N_("build a temporary index based on embedded index information")),4336{ OPTION_CALLBACK,'z', NULL, NULL, NULL,4337N_("paths are separated with NUL character"),4338 PARSE_OPT_NOARG, option_parse_z },4339OPT_INTEGER('C', NULL, &p_context,4340N_("ensure at least <n> lines of context match")),4341{ OPTION_CALLBACK,0,"whitespace", &whitespace_option,N_("action"),4342N_("detect new or modified lines that have whitespace errors"),43430, option_parse_whitespace },4344{ OPTION_CALLBACK,0,"ignore-space-change", NULL, NULL,4345N_("ignore changes in whitespace when finding context"),4346 PARSE_OPT_NOARG, option_parse_space_change },4347{ OPTION_CALLBACK,0,"ignore-whitespace", NULL, NULL,4348N_("ignore changes in whitespace when finding context"),4349 PARSE_OPT_NOARG, option_parse_space_change },4350OPT_BOOLEAN('R',"reverse", &apply_in_reverse,4351N_("apply the patch in reverse")),4352OPT_BOOLEAN(0,"unidiff-zero", &unidiff_zero,4353N_("don't expect at least one line of context")),4354OPT_BOOLEAN(0,"reject", &apply_with_reject,4355N_("leave the rejected hunks in corresponding *.rej files")),4356OPT_BOOLEAN(0,"allow-overlap", &allow_overlap,4357N_("allow overlapping hunks")),4358OPT__VERBOSE(&apply_verbosely,N_("be verbose")),4359OPT_BIT(0,"inaccurate-eof", &options,4360N_("tolerate incorrectly detected missing new-line at the end of file"),4361 INACCURATE_EOF),4362OPT_BIT(0,"recount", &options,4363N_("do not trust the line counts in the hunk headers"),4364 RECOUNT),4365{ OPTION_CALLBACK,0,"directory", NULL,N_("root"),4366N_("prepend <root> to all filenames"),43670, option_parse_directory },4368OPT_END()4369};43704371 prefix = prefix_;4372 prefix_length = prefix ?strlen(prefix) :0;4373git_config(git_apply_config, NULL);4374if(apply_default_whitespace)4375parse_whitespace_option(apply_default_whitespace);4376if(apply_default_ignorewhitespace)4377parse_ignorewhitespace_option(apply_default_ignorewhitespace);43784379 argc =parse_options(argc, argv, prefix, builtin_apply_options,4380 apply_usage,0);43814382if(apply_with_reject && threeway)4383die("--reject and --3way cannot be used together.");4384if(cached && threeway)4385die("--cached and --3way cannot be used together.");4386if(threeway) {4387if(is_not_gitdir)4388die(_("--3way outside a repository"));4389 check_index =1;4390}4391if(apply_with_reject)4392 apply = apply_verbosely =1;4393if(!force_apply && (diffstat || numstat || summary || check || fake_ancestor))4394 apply =0;4395if(check_index && is_not_gitdir)4396die(_("--index outside a repository"));4397if(cached) {4398if(is_not_gitdir)4399die(_("--cached outside a repository"));4400 check_index =1;4401}4402for(i =0; i < argc; i++) {4403const char*arg = argv[i];4404int fd;44054406if(!strcmp(arg,"-")) {4407 errs |=apply_patch(0,"<stdin>", options);4408 read_stdin =0;4409continue;4410}else if(0< prefix_length)4411 arg =prefix_filename(prefix, prefix_length, arg);44124413 fd =open(arg, O_RDONLY);4414if(fd <0)4415die_errno(_("can't open patch '%s'"), arg);4416 read_stdin =0;4417set_default_whitespace_mode(whitespace_option);4418 errs |=apply_patch(fd, arg, options);4419close(fd);4420}4421set_default_whitespace_mode(whitespace_option);4422if(read_stdin)4423 errs |=apply_patch(0,"<stdin>", options);4424if(whitespace_error) {4425if(squelch_whitespace_errors &&4426 squelch_whitespace_errors < whitespace_error) {4427int squelched =4428 whitespace_error - squelch_whitespace_errors;4429warning(Q_("squelched%dwhitespace error",4430"squelched%dwhitespace errors",4431 squelched),4432 squelched);4433}4434if(ws_error_action == die_on_ws_error)4435die(Q_("%dline adds whitespace errors.",4436"%dlines add whitespace errors.",4437 whitespace_error),4438 whitespace_error);4439if(applied_after_fixing_ws && apply)4440warning("%dline%sapplied after"4441" fixing whitespace errors.",4442 applied_after_fixing_ws,4443 applied_after_fixing_ws ==1?"":"s");4444else if(whitespace_error)4445warning(Q_("%dline adds whitespace errors.",4446"%dlines add whitespace errors.",4447 whitespace_error),4448 whitespace_error);4449}44504451if(update_index) {4452if(write_cache(newfd, active_cache, active_nr) ||4453commit_locked_index(&lock_file))4454die(_("Unable to write new index file"));4455}44564457return!!errs;4458}