1/* 2 * Builtin "git am" 3 * 4 * Based on git-am.sh by Junio C Hamano. 5 */ 6#include"cache.h" 7#include"builtin.h" 8#include"exec_cmd.h" 9#include"parse-options.h" 10#include"dir.h" 11#include"run-command.h" 12#include"quote.h" 13#include"tempfile.h" 14#include"lockfile.h" 15#include"cache-tree.h" 16#include"refs.h" 17#include"commit.h" 18#include"diff.h" 19#include"diffcore.h" 20#include"unpack-trees.h" 21#include"branch.h" 22#include"sequencer.h" 23#include"revision.h" 24#include"merge-recursive.h" 25#include"revision.h" 26#include"log-tree.h" 27#include"notes-utils.h" 28#include"rerere.h" 29#include"prompt.h" 30#include"mailinfo.h" 31#include"apply.h" 32#include"string-list.h" 33 34/** 35 * Returns 1 if the file is empty or does not exist, 0 otherwise. 36 */ 37static intis_empty_file(const char*filename) 38{ 39struct stat st; 40 41if(stat(filename, &st) <0) { 42if(errno == ENOENT) 43return1; 44die_errno(_("could not stat%s"), filename); 45} 46 47return!st.st_size; 48} 49 50/** 51 * Returns the length of the first line of msg. 52 */ 53static intlinelen(const char*msg) 54{ 55returnstrchrnul(msg,'\n') - msg; 56} 57 58/** 59 * Returns true if `str` consists of only whitespace, false otherwise. 60 */ 61static intstr_isspace(const char*str) 62{ 63for(; *str; str++) 64if(!isspace(*str)) 65return0; 66 67return1; 68} 69 70enum patch_format { 71 PATCH_FORMAT_UNKNOWN =0, 72 PATCH_FORMAT_MBOX, 73 PATCH_FORMAT_STGIT, 74 PATCH_FORMAT_STGIT_SERIES, 75 PATCH_FORMAT_HG, 76 PATCH_FORMAT_MBOXRD 77}; 78 79enum keep_type { 80 KEEP_FALSE =0, 81 KEEP_TRUE,/* pass -k flag to git-mailinfo */ 82 KEEP_NON_PATCH /* pass -b flag to git-mailinfo */ 83}; 84 85enum scissors_type { 86 SCISSORS_UNSET = -1, 87 SCISSORS_FALSE =0,/* pass --no-scissors to git-mailinfo */ 88 SCISSORS_TRUE /* pass --scissors to git-mailinfo */ 89}; 90 91enum signoff_type { 92 SIGNOFF_FALSE =0, 93 SIGNOFF_TRUE =1, 94 SIGNOFF_EXPLICIT /* --signoff was set on the command-line */ 95}; 96 97struct am_state { 98/* state directory path */ 99char*dir; 100 101/* current and last patch numbers, 1-indexed */ 102int cur; 103int last; 104 105/* commit metadata and message */ 106char*author_name; 107char*author_email; 108char*author_date; 109char*msg; 110size_t msg_len; 111 112/* when --rebasing, records the original commit the patch came from */ 113struct object_id orig_commit; 114 115/* number of digits in patch filename */ 116int prec; 117 118/* various operating modes and command line options */ 119int interactive; 120int threeway; 121int quiet; 122int signoff;/* enum signoff_type */ 123int utf8; 124int keep;/* enum keep_type */ 125int message_id; 126int scissors;/* enum scissors_type */ 127struct argv_array git_apply_opts; 128const char*resolvemsg; 129int committer_date_is_author_date; 130int ignore_date; 131int allow_rerere_autoupdate; 132const char*sign_commit; 133int rebasing; 134}; 135 136/** 137 * Initializes am_state with the default values. 138 */ 139static voidam_state_init(struct am_state *state) 140{ 141int gpgsign; 142 143memset(state,0,sizeof(*state)); 144 145 state->dir =git_pathdup("rebase-apply"); 146 147 state->prec =4; 148 149git_config_get_bool("am.threeway", &state->threeway); 150 151 state->utf8 =1; 152 153git_config_get_bool("am.messageid", &state->message_id); 154 155 state->scissors = SCISSORS_UNSET; 156 157argv_array_init(&state->git_apply_opts); 158 159if(!git_config_get_bool("commit.gpgsign", &gpgsign)) 160 state->sign_commit = gpgsign ?"": NULL; 161} 162 163/** 164 * Releases memory allocated by an am_state. 165 */ 166static voidam_state_release(struct am_state *state) 167{ 168free(state->dir); 169free(state->author_name); 170free(state->author_email); 171free(state->author_date); 172free(state->msg); 173argv_array_clear(&state->git_apply_opts); 174} 175 176/** 177 * Returns path relative to the am_state directory. 178 */ 179staticinlineconst char*am_path(const struct am_state *state,const char*path) 180{ 181returnmkpath("%s/%s", state->dir, path); 182} 183 184/** 185 * For convenience to call write_file() 186 */ 187static voidwrite_state_text(const struct am_state *state, 188const char*name,const char*string) 189{ 190write_file(am_path(state, name),"%s", string); 191} 192 193static voidwrite_state_count(const struct am_state *state, 194const char*name,int value) 195{ 196write_file(am_path(state, name),"%d", value); 197} 198 199static voidwrite_state_bool(const struct am_state *state, 200const char*name,int value) 201{ 202write_state_text(state, name, value ?"t":"f"); 203} 204 205/** 206 * If state->quiet is false, calls fprintf(fp, fmt, ...), and appends a newline 207 * at the end. 208 */ 209static voidsay(const struct am_state *state,FILE*fp,const char*fmt, ...) 210{ 211va_list ap; 212 213va_start(ap, fmt); 214if(!state->quiet) { 215vfprintf(fp, fmt, ap); 216putc('\n', fp); 217} 218va_end(ap); 219} 220 221/** 222 * Returns 1 if there is an am session in progress, 0 otherwise. 223 */ 224static intam_in_progress(const struct am_state *state) 225{ 226struct stat st; 227 228if(lstat(state->dir, &st) <0|| !S_ISDIR(st.st_mode)) 229return0; 230if(lstat(am_path(state,"last"), &st) || !S_ISREG(st.st_mode)) 231return0; 232if(lstat(am_path(state,"next"), &st) || !S_ISREG(st.st_mode)) 233return0; 234return1; 235} 236 237/** 238 * Reads the contents of `file` in the `state` directory into `sb`. Returns the 239 * number of bytes read on success, -1 if the file does not exist. If `trim` is 240 * set, trailing whitespace will be removed. 241 */ 242static intread_state_file(struct strbuf *sb,const struct am_state *state, 243const char*file,int trim) 244{ 245strbuf_reset(sb); 246 247if(strbuf_read_file(sb,am_path(state, file),0) >=0) { 248if(trim) 249strbuf_trim(sb); 250 251return sb->len; 252} 253 254if(errno == ENOENT) 255return-1; 256 257die_errno(_("could not read '%s'"),am_path(state, file)); 258} 259 260/** 261 * Take a series of KEY='VALUE' lines where VALUE part is 262 * sq-quoted, and append <KEY, VALUE> at the end of the string list 263 */ 264static intparse_key_value_squoted(char*buf,struct string_list *list) 265{ 266while(*buf) { 267struct string_list_item *item; 268char*np; 269char*cp =strchr(buf,'='); 270if(!cp) 271return-1; 272 np =strchrnul(cp,'\n'); 273*cp++ ='\0'; 274 item =string_list_append(list, buf); 275 276 buf = np + (*np =='\n'); 277*np ='\0'; 278 cp =sq_dequote(cp); 279if(!cp) 280return-1; 281 item->util =xstrdup(cp); 282} 283return0; 284} 285 286/** 287 * Reads and parses the state directory's "author-script" file, and sets 288 * state->author_name, state->author_email and state->author_date accordingly. 289 * Returns 0 on success, -1 if the file could not be parsed. 290 * 291 * The author script is of the format: 292 * 293 * GIT_AUTHOR_NAME='$author_name' 294 * GIT_AUTHOR_EMAIL='$author_email' 295 * GIT_AUTHOR_DATE='$author_date' 296 * 297 * where $author_name, $author_email and $author_date are quoted. We are strict 298 * with our parsing, as the file was meant to be eval'd in the old git-am.sh 299 * script, and thus if the file differs from what this function expects, it is 300 * better to bail out than to do something that the user does not expect. 301 */ 302static intread_author_script(struct am_state *state) 303{ 304const char*filename =am_path(state,"author-script"); 305struct strbuf buf = STRBUF_INIT; 306struct string_list kv = STRING_LIST_INIT_DUP; 307int retval = -1;/* assume failure */ 308int fd; 309 310assert(!state->author_name); 311assert(!state->author_email); 312assert(!state->author_date); 313 314 fd =open(filename, O_RDONLY); 315if(fd <0) { 316if(errno == ENOENT) 317return0; 318die_errno(_("could not open '%s' for reading"), filename); 319} 320strbuf_read(&buf, fd,0); 321close(fd); 322if(parse_key_value_squoted(buf.buf, &kv)) 323goto finish; 324 325if(kv.nr !=3|| 326strcmp(kv.items[0].string,"GIT_AUTHOR_NAME") || 327strcmp(kv.items[1].string,"GIT_AUTHOR_EMAIL") || 328strcmp(kv.items[2].string,"GIT_AUTHOR_DATE")) 329goto finish; 330 state->author_name = kv.items[0].util; 331 state->author_email = kv.items[1].util; 332 state->author_date = kv.items[2].util; 333 retval =0; 334finish: 335string_list_clear(&kv, !!retval); 336strbuf_release(&buf); 337return retval; 338} 339 340/** 341 * Saves state->author_name, state->author_email and state->author_date in the 342 * state directory's "author-script" file. 343 */ 344static voidwrite_author_script(const struct am_state *state) 345{ 346struct strbuf sb = STRBUF_INIT; 347 348strbuf_addstr(&sb,"GIT_AUTHOR_NAME="); 349sq_quote_buf(&sb, state->author_name); 350strbuf_addch(&sb,'\n'); 351 352strbuf_addstr(&sb,"GIT_AUTHOR_EMAIL="); 353sq_quote_buf(&sb, state->author_email); 354strbuf_addch(&sb,'\n'); 355 356strbuf_addstr(&sb,"GIT_AUTHOR_DATE="); 357sq_quote_buf(&sb, state->author_date); 358strbuf_addch(&sb,'\n'); 359 360write_state_text(state,"author-script", sb.buf); 361 362strbuf_release(&sb); 363} 364 365/** 366 * Reads the commit message from the state directory's "final-commit" file, 367 * setting state->msg to its contents and state->msg_len to the length of its 368 * contents in bytes. 369 * 370 * Returns 0 on success, -1 if the file does not exist. 371 */ 372static intread_commit_msg(struct am_state *state) 373{ 374struct strbuf sb = STRBUF_INIT; 375 376assert(!state->msg); 377 378if(read_state_file(&sb, state,"final-commit",0) <0) { 379strbuf_release(&sb); 380return-1; 381} 382 383 state->msg =strbuf_detach(&sb, &state->msg_len); 384return0; 385} 386 387/** 388 * Saves state->msg in the state directory's "final-commit" file. 389 */ 390static voidwrite_commit_msg(const struct am_state *state) 391{ 392const char*filename =am_path(state,"final-commit"); 393write_file_buf(filename, state->msg, state->msg_len); 394} 395 396/** 397 * Loads state from disk. 398 */ 399static voidam_load(struct am_state *state) 400{ 401struct strbuf sb = STRBUF_INIT; 402 403if(read_state_file(&sb, state,"next",1) <0) 404die("BUG: state file 'next' does not exist"); 405 state->cur =strtol(sb.buf, NULL,10); 406 407if(read_state_file(&sb, state,"last",1) <0) 408die("BUG: state file 'last' does not exist"); 409 state->last =strtol(sb.buf, NULL,10); 410 411if(read_author_script(state) <0) 412die(_("could not parse author script")); 413 414read_commit_msg(state); 415 416if(read_state_file(&sb, state,"original-commit",1) <0) 417oidclr(&state->orig_commit); 418else if(get_oid_hex(sb.buf, &state->orig_commit) <0) 419die(_("could not parse%s"),am_path(state,"original-commit")); 420 421read_state_file(&sb, state,"threeway",1); 422 state->threeway = !strcmp(sb.buf,"t"); 423 424read_state_file(&sb, state,"quiet",1); 425 state->quiet = !strcmp(sb.buf,"t"); 426 427read_state_file(&sb, state,"sign",1); 428 state->signoff = !strcmp(sb.buf,"t"); 429 430read_state_file(&sb, state,"utf8",1); 431 state->utf8 = !strcmp(sb.buf,"t"); 432 433read_state_file(&sb, state,"keep",1); 434if(!strcmp(sb.buf,"t")) 435 state->keep = KEEP_TRUE; 436else if(!strcmp(sb.buf,"b")) 437 state->keep = KEEP_NON_PATCH; 438else 439 state->keep = KEEP_FALSE; 440 441read_state_file(&sb, state,"messageid",1); 442 state->message_id = !strcmp(sb.buf,"t"); 443 444read_state_file(&sb, state,"scissors",1); 445if(!strcmp(sb.buf,"t")) 446 state->scissors = SCISSORS_TRUE; 447else if(!strcmp(sb.buf,"f")) 448 state->scissors = SCISSORS_FALSE; 449else 450 state->scissors = SCISSORS_UNSET; 451 452read_state_file(&sb, state,"apply-opt",1); 453argv_array_clear(&state->git_apply_opts); 454if(sq_dequote_to_argv_array(sb.buf, &state->git_apply_opts) <0) 455die(_("could not parse%s"),am_path(state,"apply-opt")); 456 457 state->rebasing = !!file_exists(am_path(state,"rebasing")); 458 459strbuf_release(&sb); 460} 461 462/** 463 * Removes the am_state directory, forcefully terminating the current am 464 * session. 465 */ 466static voidam_destroy(const struct am_state *state) 467{ 468struct strbuf sb = STRBUF_INIT; 469 470strbuf_addstr(&sb, state->dir); 471remove_dir_recursively(&sb,0); 472strbuf_release(&sb); 473} 474 475/** 476 * Runs applypatch-msg hook. Returns its exit code. 477 */ 478static intrun_applypatch_msg_hook(struct am_state *state) 479{ 480int ret; 481 482assert(state->msg); 483 ret =run_hook_le(NULL,"applypatch-msg",am_path(state,"final-commit"), NULL); 484 485if(!ret) { 486free(state->msg); 487 state->msg = NULL; 488if(read_commit_msg(state) <0) 489die(_("'%s' was deleted by the applypatch-msg hook"), 490am_path(state,"final-commit")); 491} 492 493return ret; 494} 495 496/** 497 * Runs post-rewrite hook. Returns it exit code. 498 */ 499static intrun_post_rewrite_hook(const struct am_state *state) 500{ 501struct child_process cp = CHILD_PROCESS_INIT; 502const char*hook =find_hook("post-rewrite"); 503int ret; 504 505if(!hook) 506return0; 507 508argv_array_push(&cp.args, hook); 509argv_array_push(&cp.args,"rebase"); 510 511 cp.in =xopen(am_path(state,"rewritten"), O_RDONLY); 512 cp.stdout_to_stderr =1; 513 514 ret =run_command(&cp); 515 516close(cp.in); 517return ret; 518} 519 520/** 521 * Reads the state directory's "rewritten" file, and copies notes from the old 522 * commits listed in the file to their rewritten commits. 523 * 524 * Returns 0 on success, -1 on failure. 525 */ 526static intcopy_notes_for_rebase(const struct am_state *state) 527{ 528struct notes_rewrite_cfg *c; 529struct strbuf sb = STRBUF_INIT; 530const char*invalid_line =_("Malformed input line: '%s'."); 531const char*msg ="Notes added by 'git rebase'"; 532FILE*fp; 533int ret =0; 534 535assert(state->rebasing); 536 537 c =init_copy_notes_for_rewrite("rebase"); 538if(!c) 539return0; 540 541 fp =xfopen(am_path(state,"rewritten"),"r"); 542 543while(!strbuf_getline_lf(&sb, fp)) { 544struct object_id from_obj, to_obj; 545 546if(sb.len != GIT_SHA1_HEXSZ *2+1) { 547 ret =error(invalid_line, sb.buf); 548goto finish; 549} 550 551if(get_oid_hex(sb.buf, &from_obj)) { 552 ret =error(invalid_line, sb.buf); 553goto finish; 554} 555 556if(sb.buf[GIT_SHA1_HEXSZ] !=' ') { 557 ret =error(invalid_line, sb.buf); 558goto finish; 559} 560 561if(get_oid_hex(sb.buf + GIT_SHA1_HEXSZ +1, &to_obj)) { 562 ret =error(invalid_line, sb.buf); 563goto finish; 564} 565 566if(copy_note_for_rewrite(c, from_obj.hash, to_obj.hash)) 567 ret =error(_("Failed to copy notes from '%s' to '%s'"), 568oid_to_hex(&from_obj),oid_to_hex(&to_obj)); 569} 570 571finish: 572finish_copy_notes_for_rewrite(c, msg); 573fclose(fp); 574strbuf_release(&sb); 575return ret; 576} 577 578/** 579 * Determines if the file looks like a piece of RFC2822 mail by grabbing all 580 * non-indented lines and checking if they look like they begin with valid 581 * header field names. 582 * 583 * Returns 1 if the file looks like a piece of mail, 0 otherwise. 584 */ 585static intis_mail(FILE*fp) 586{ 587const char*header_regex ="^[!-9;-~]+:"; 588struct strbuf sb = STRBUF_INIT; 589 regex_t regex; 590int ret =1; 591 592if(fseek(fp,0L, SEEK_SET)) 593die_errno(_("fseek failed")); 594 595if(regcomp(®ex, header_regex, REG_NOSUB | REG_EXTENDED)) 596die("invalid pattern:%s", header_regex); 597 598while(!strbuf_getline(&sb, fp)) { 599if(!sb.len) 600break;/* End of header */ 601 602/* Ignore indented folded lines */ 603if(*sb.buf =='\t'|| *sb.buf ==' ') 604continue; 605 606/* It's a header if it matches header_regex */ 607if(regexec(®ex, sb.buf,0, NULL,0)) { 608 ret =0; 609goto done; 610} 611} 612 613done: 614regfree(®ex); 615strbuf_release(&sb); 616return ret; 617} 618 619/** 620 * Attempts to detect the patch_format of the patches contained in `paths`, 621 * returning the PATCH_FORMAT_* enum value. Returns PATCH_FORMAT_UNKNOWN if 622 * detection fails. 623 */ 624static intdetect_patch_format(const char**paths) 625{ 626enum patch_format ret = PATCH_FORMAT_UNKNOWN; 627struct strbuf l1 = STRBUF_INIT; 628struct strbuf l2 = STRBUF_INIT; 629struct strbuf l3 = STRBUF_INIT; 630FILE*fp; 631 632/* 633 * We default to mbox format if input is from stdin and for directories 634 */ 635if(!*paths || !strcmp(*paths,"-") ||is_directory(*paths)) 636return PATCH_FORMAT_MBOX; 637 638/* 639 * Otherwise, check the first few lines of the first patch, starting 640 * from the first non-blank line, to try to detect its format. 641 */ 642 643 fp =xfopen(*paths,"r"); 644 645while(!strbuf_getline(&l1, fp)) { 646if(l1.len) 647break; 648} 649 650if(starts_with(l1.buf,"From ") ||starts_with(l1.buf,"From: ")) { 651 ret = PATCH_FORMAT_MBOX; 652goto done; 653} 654 655if(starts_with(l1.buf,"# This series applies on GIT commit")) { 656 ret = PATCH_FORMAT_STGIT_SERIES; 657goto done; 658} 659 660if(!strcmp(l1.buf,"# HG changeset patch")) { 661 ret = PATCH_FORMAT_HG; 662goto done; 663} 664 665strbuf_reset(&l2); 666strbuf_getline(&l2, fp); 667strbuf_reset(&l3); 668strbuf_getline(&l3, fp); 669 670/* 671 * If the second line is empty and the third is a From, Author or Date 672 * entry, this is likely an StGit patch. 673 */ 674if(l1.len && !l2.len && 675(starts_with(l3.buf,"From:") || 676starts_with(l3.buf,"Author:") || 677starts_with(l3.buf,"Date:"))) { 678 ret = PATCH_FORMAT_STGIT; 679goto done; 680} 681 682if(l1.len &&is_mail(fp)) { 683 ret = PATCH_FORMAT_MBOX; 684goto done; 685} 686 687done: 688fclose(fp); 689strbuf_release(&l1); 690return ret; 691} 692 693/** 694 * Splits out individual email patches from `paths`, where each path is either 695 * a mbox file or a Maildir. Returns 0 on success, -1 on failure. 696 */ 697static intsplit_mail_mbox(struct am_state *state,const char**paths, 698int keep_cr,int mboxrd) 699{ 700struct child_process cp = CHILD_PROCESS_INIT; 701struct strbuf last = STRBUF_INIT; 702 703 cp.git_cmd =1; 704argv_array_push(&cp.args,"mailsplit"); 705argv_array_pushf(&cp.args,"-d%d", state->prec); 706argv_array_pushf(&cp.args,"-o%s", state->dir); 707argv_array_push(&cp.args,"-b"); 708if(keep_cr) 709argv_array_push(&cp.args,"--keep-cr"); 710if(mboxrd) 711argv_array_push(&cp.args,"--mboxrd"); 712argv_array_push(&cp.args,"--"); 713argv_array_pushv(&cp.args, paths); 714 715if(capture_command(&cp, &last,8)) 716return-1; 717 718 state->cur =1; 719 state->last =strtol(last.buf, NULL,10); 720 721return0; 722} 723 724/** 725 * Callback signature for split_mail_conv(). The foreign patch should be 726 * read from `in`, and the converted patch (in RFC2822 mail format) should be 727 * written to `out`. Return 0 on success, or -1 on failure. 728 */ 729typedefint(*mail_conv_fn)(FILE*out,FILE*in,int keep_cr); 730 731/** 732 * Calls `fn` for each file in `paths` to convert the foreign patch to the 733 * RFC2822 mail format suitable for parsing with git-mailinfo. 734 * 735 * Returns 0 on success, -1 on failure. 736 */ 737static intsplit_mail_conv(mail_conv_fn fn,struct am_state *state, 738const char**paths,int keep_cr) 739{ 740static const char*stdin_only[] = {"-", NULL}; 741int i; 742 743if(!*paths) 744 paths = stdin_only; 745 746for(i =0; *paths; paths++, i++) { 747FILE*in, *out; 748const char*mail; 749int ret; 750 751if(!strcmp(*paths,"-")) 752 in = stdin; 753else 754 in =fopen(*paths,"r"); 755 756if(!in) 757returnerror_errno(_("could not open '%s' for reading"), 758*paths); 759 760 mail =mkpath("%s/%0*d", state->dir, state->prec, i +1); 761 762 out =fopen(mail,"w"); 763if(!out) { 764if(in != stdin) 765fclose(in); 766returnerror_errno(_("could not open '%s' for writing"), 767 mail); 768} 769 770 ret =fn(out, in, keep_cr); 771 772fclose(out); 773if(in != stdin) 774fclose(in); 775 776if(ret) 777returnerror(_("could not parse patch '%s'"), *paths); 778} 779 780 state->cur =1; 781 state->last = i; 782return0; 783} 784 785/** 786 * A split_mail_conv() callback that converts an StGit patch to an RFC2822 787 * message suitable for parsing with git-mailinfo. 788 */ 789static intstgit_patch_to_mail(FILE*out,FILE*in,int keep_cr) 790{ 791struct strbuf sb = STRBUF_INIT; 792int subject_printed =0; 793 794while(!strbuf_getline_lf(&sb, in)) { 795const char*str; 796 797if(str_isspace(sb.buf)) 798continue; 799else if(skip_prefix(sb.buf,"Author:", &str)) 800fprintf(out,"From:%s\n", str); 801else if(starts_with(sb.buf,"From") ||starts_with(sb.buf,"Date")) 802fprintf(out,"%s\n", sb.buf); 803else if(!subject_printed) { 804fprintf(out,"Subject:%s\n", sb.buf); 805 subject_printed =1; 806}else{ 807fprintf(out,"\n%s\n", sb.buf); 808break; 809} 810} 811 812strbuf_reset(&sb); 813while(strbuf_fread(&sb,8192, in) >0) { 814fwrite(sb.buf,1, sb.len, out); 815strbuf_reset(&sb); 816} 817 818strbuf_release(&sb); 819return0; 820} 821 822/** 823 * This function only supports a single StGit series file in `paths`. 824 * 825 * Given an StGit series file, converts the StGit patches in the series into 826 * RFC2822 messages suitable for parsing with git-mailinfo, and queues them in 827 * the state directory. 828 * 829 * Returns 0 on success, -1 on failure. 830 */ 831static intsplit_mail_stgit_series(struct am_state *state,const char**paths, 832int keep_cr) 833{ 834const char*series_dir; 835char*series_dir_buf; 836FILE*fp; 837struct argv_array patches = ARGV_ARRAY_INIT; 838struct strbuf sb = STRBUF_INIT; 839int ret; 840 841if(!paths[0] || paths[1]) 842returnerror(_("Only one StGIT patch series can be applied at once")); 843 844 series_dir_buf =xstrdup(*paths); 845 series_dir =dirname(series_dir_buf); 846 847 fp =fopen(*paths,"r"); 848if(!fp) 849returnerror_errno(_("could not open '%s' for reading"), *paths); 850 851while(!strbuf_getline_lf(&sb, fp)) { 852if(*sb.buf =='#') 853continue;/* skip comment lines */ 854 855argv_array_push(&patches,mkpath("%s/%s", series_dir, sb.buf)); 856} 857 858fclose(fp); 859strbuf_release(&sb); 860free(series_dir_buf); 861 862 ret =split_mail_conv(stgit_patch_to_mail, state, patches.argv, keep_cr); 863 864argv_array_clear(&patches); 865return ret; 866} 867 868/** 869 * A split_patches_conv() callback that converts a mercurial patch to a RFC2822 870 * message suitable for parsing with git-mailinfo. 871 */ 872static inthg_patch_to_mail(FILE*out,FILE*in,int keep_cr) 873{ 874struct strbuf sb = STRBUF_INIT; 875 876while(!strbuf_getline_lf(&sb, in)) { 877const char*str; 878 879if(skip_prefix(sb.buf,"# User ", &str)) 880fprintf(out,"From:%s\n", str); 881else if(skip_prefix(sb.buf,"# Date ", &str)) { 882unsigned long timestamp; 883long tz, tz2; 884char*end; 885 886 errno =0; 887 timestamp =strtoul(str, &end,10); 888if(errno) 889returnerror(_("invalid timestamp")); 890 891if(!skip_prefix(end," ", &str)) 892returnerror(_("invalid Date line")); 893 894 errno =0; 895 tz =strtol(str, &end,10); 896if(errno) 897returnerror(_("invalid timezone offset")); 898 899if(*end) 900returnerror(_("invalid Date line")); 901 902/* 903 * mercurial's timezone is in seconds west of UTC, 904 * however git's timezone is in hours + minutes east of 905 * UTC. Convert it. 906 */ 907 tz2 =labs(tz) /3600*100+labs(tz) %3600/60; 908if(tz >0) 909 tz2 = -tz2; 910 911fprintf(out,"Date:%s\n",show_date(timestamp, tz2,DATE_MODE(RFC2822))); 912}else if(starts_with(sb.buf,"# ")) { 913continue; 914}else{ 915fprintf(out,"\n%s\n", sb.buf); 916break; 917} 918} 919 920strbuf_reset(&sb); 921while(strbuf_fread(&sb,8192, in) >0) { 922fwrite(sb.buf,1, sb.len, out); 923strbuf_reset(&sb); 924} 925 926strbuf_release(&sb); 927return0; 928} 929 930/** 931 * Splits a list of files/directories into individual email patches. Each path 932 * in `paths` must be a file/directory that is formatted according to 933 * `patch_format`. 934 * 935 * Once split out, the individual email patches will be stored in the state 936 * directory, with each patch's filename being its index, padded to state->prec 937 * digits. 938 * 939 * state->cur will be set to the index of the first mail, and state->last will 940 * be set to the index of the last mail. 941 * 942 * Set keep_cr to 0 to convert all lines ending with \r\n to end with \n, 1 943 * to disable this behavior, -1 to use the default configured setting. 944 * 945 * Returns 0 on success, -1 on failure. 946 */ 947static intsplit_mail(struct am_state *state,enum patch_format patch_format, 948const char**paths,int keep_cr) 949{ 950if(keep_cr <0) { 951 keep_cr =0; 952git_config_get_bool("am.keepcr", &keep_cr); 953} 954 955switch(patch_format) { 956case PATCH_FORMAT_MBOX: 957returnsplit_mail_mbox(state, paths, keep_cr,0); 958case PATCH_FORMAT_STGIT: 959returnsplit_mail_conv(stgit_patch_to_mail, state, paths, keep_cr); 960case PATCH_FORMAT_STGIT_SERIES: 961returnsplit_mail_stgit_series(state, paths, keep_cr); 962case PATCH_FORMAT_HG: 963returnsplit_mail_conv(hg_patch_to_mail, state, paths, keep_cr); 964case PATCH_FORMAT_MBOXRD: 965returnsplit_mail_mbox(state, paths, keep_cr,1); 966default: 967die("BUG: invalid patch_format"); 968} 969return-1; 970} 971 972/** 973 * Setup a new am session for applying patches 974 */ 975static voidam_setup(struct am_state *state,enum patch_format patch_format, 976const char**paths,int keep_cr) 977{ 978struct object_id curr_head; 979const char*str; 980struct strbuf sb = STRBUF_INIT; 981 982if(!patch_format) 983 patch_format =detect_patch_format(paths); 984 985if(!patch_format) { 986fprintf_ln(stderr,_("Patch format detection failed.")); 987exit(128); 988} 989 990if(mkdir(state->dir,0777) <0&& errno != EEXIST) 991die_errno(_("failed to create directory '%s'"), state->dir); 992 993if(split_mail(state, patch_format, paths, keep_cr) <0) { 994am_destroy(state); 995die(_("Failed to split patches.")); 996} 997 998if(state->rebasing) 999 state->threeway =1;10001001write_state_bool(state,"threeway", state->threeway);1002write_state_bool(state,"quiet", state->quiet);1003write_state_bool(state,"sign", state->signoff);1004write_state_bool(state,"utf8", state->utf8);10051006switch(state->keep) {1007case KEEP_FALSE:1008 str ="f";1009break;1010case KEEP_TRUE:1011 str ="t";1012break;1013case KEEP_NON_PATCH:1014 str ="b";1015break;1016default:1017die("BUG: invalid value for state->keep");1018}10191020write_state_text(state,"keep", str);1021write_state_bool(state,"messageid", state->message_id);10221023switch(state->scissors) {1024case SCISSORS_UNSET:1025 str ="";1026break;1027case SCISSORS_FALSE:1028 str ="f";1029break;1030case SCISSORS_TRUE:1031 str ="t";1032break;1033default:1034die("BUG: invalid value for state->scissors");1035}1036write_state_text(state,"scissors", str);10371038sq_quote_argv(&sb, state->git_apply_opts.argv,0);1039write_state_text(state,"apply-opt", sb.buf);10401041if(state->rebasing)1042write_state_text(state,"rebasing","");1043else1044write_state_text(state,"applying","");10451046if(!get_oid("HEAD", &curr_head)) {1047write_state_text(state,"abort-safety",oid_to_hex(&curr_head));1048if(!state->rebasing)1049update_ref_oid("am","ORIG_HEAD", &curr_head, NULL,0,1050 UPDATE_REFS_DIE_ON_ERR);1051}else{1052write_state_text(state,"abort-safety","");1053if(!state->rebasing)1054delete_ref(NULL,"ORIG_HEAD", NULL,0);1055}10561057/*1058 * NOTE: Since the "next" and "last" files determine if an am_state1059 * session is in progress, they should be written last.1060 */10611062write_state_count(state,"next", state->cur);1063write_state_count(state,"last", state->last);10641065strbuf_release(&sb);1066}10671068/**1069 * Increments the patch pointer, and cleans am_state for the application of the1070 * next patch.1071 */1072static voidam_next(struct am_state *state)1073{1074struct object_id head;10751076free(state->author_name);1077 state->author_name = NULL;10781079free(state->author_email);1080 state->author_email = NULL;10811082free(state->author_date);1083 state->author_date = NULL;10841085free(state->msg);1086 state->msg = NULL;1087 state->msg_len =0;10881089unlink(am_path(state,"author-script"));1090unlink(am_path(state,"final-commit"));10911092oidclr(&state->orig_commit);1093unlink(am_path(state,"original-commit"));10941095if(!get_oid("HEAD", &head))1096write_state_text(state,"abort-safety",oid_to_hex(&head));1097else1098write_state_text(state,"abort-safety","");10991100 state->cur++;1101write_state_count(state,"next", state->cur);1102}11031104/**1105 * Returns the filename of the current patch email.1106 */1107static const char*msgnum(const struct am_state *state)1108{1109static struct strbuf sb = STRBUF_INIT;11101111strbuf_reset(&sb);1112strbuf_addf(&sb,"%0*d", state->prec, state->cur);11131114return sb.buf;1115}11161117/**1118 * Refresh and write index.1119 */1120static voidrefresh_and_write_cache(void)1121{1122struct lock_file *lock_file =xcalloc(1,sizeof(struct lock_file));11231124hold_locked_index(lock_file, LOCK_DIE_ON_ERROR);1125refresh_cache(REFRESH_QUIET);1126if(write_locked_index(&the_index, lock_file, COMMIT_LOCK))1127die(_("unable to write index file"));1128}11291130/**1131 * Returns 1 if the index differs from HEAD, 0 otherwise. When on an unborn1132 * branch, returns 1 if there are entries in the index, 0 otherwise. If an1133 * strbuf is provided, the space-separated list of files that differ will be1134 * appended to it.1135 */1136static intindex_has_changes(struct strbuf *sb)1137{1138struct object_id head;1139int i;11401141if(!get_sha1_tree("HEAD", head.hash)) {1142struct diff_options opt;11431144diff_setup(&opt);1145DIFF_OPT_SET(&opt, EXIT_WITH_STATUS);1146if(!sb)1147DIFF_OPT_SET(&opt, QUICK);1148do_diff_cache(head.hash, &opt);1149diffcore_std(&opt);1150for(i =0; sb && i < diff_queued_diff.nr; i++) {1151if(i)1152strbuf_addch(sb,' ');1153strbuf_addstr(sb, diff_queued_diff.queue[i]->two->path);1154}1155diff_flush(&opt);1156returnDIFF_OPT_TST(&opt, HAS_CHANGES) !=0;1157}else{1158for(i =0; sb && i < active_nr; i++) {1159if(i)1160strbuf_addch(sb,' ');1161strbuf_addstr(sb, active_cache[i]->name);1162}1163return!!active_nr;1164}1165}11661167/**1168 * Dies with a user-friendly message on how to proceed after resolving the1169 * problem. This message can be overridden with state->resolvemsg.1170 */1171static void NORETURN die_user_resolve(const struct am_state *state)1172{1173if(state->resolvemsg) {1174printf_ln("%s", state->resolvemsg);1175}else{1176const char*cmdline = state->interactive ?"git am -i":"git am";11771178printf_ln(_("When you have resolved this problem, run\"%s--continue\"."), cmdline);1179printf_ln(_("If you prefer to skip this patch, run\"%s--skip\"instead."), cmdline);1180printf_ln(_("To restore the original branch and stop patching, run\"%s--abort\"."), cmdline);1181}11821183exit(128);1184}11851186/**1187 * Appends signoff to the "msg" field of the am_state.1188 */1189static voidam_append_signoff(struct am_state *state)1190{1191char*cp;1192struct strbuf mine = STRBUF_INIT;1193struct strbuf sb = STRBUF_INIT;11941195strbuf_attach(&sb, state->msg, state->msg_len, state->msg_len);11961197/* our sign-off */1198strbuf_addf(&mine,"\n%s%s\n",1199 sign_off_header,1200fmt_name(getenv("GIT_COMMITTER_NAME"),1201getenv("GIT_COMMITTER_EMAIL")));12021203/* Does sb end with it already? */1204if(mine.len < sb.len &&1205!strcmp(mine.buf, sb.buf + sb.len - mine.len))1206goto exit;/* no need to duplicate */12071208/* Does it have any Signed-off-by: in the text */1209for(cp = sb.buf;1210 cp && *cp && (cp =strstr(cp, sign_off_header)) != NULL;1211 cp =strchr(cp,'\n')) {1212if(sb.buf == cp || cp[-1] =='\n')1213break;1214}12151216strbuf_addstr(&sb, mine.buf + !!cp);1217exit:1218strbuf_release(&mine);1219 state->msg =strbuf_detach(&sb, &state->msg_len);1220}12211222/**1223 * Parses `mail` using git-mailinfo, extracting its patch and authorship info.1224 * state->msg will be set to the patch message. state->author_name,1225 * state->author_email and state->author_date will be set to the patch author's1226 * name, email and date respectively. The patch body will be written to the1227 * state directory's "patch" file.1228 *1229 * Returns 1 if the patch should be skipped, 0 otherwise.1230 */1231static intparse_mail(struct am_state *state,const char*mail)1232{1233FILE*fp;1234struct strbuf sb = STRBUF_INIT;1235struct strbuf msg = STRBUF_INIT;1236struct strbuf author_name = STRBUF_INIT;1237struct strbuf author_date = STRBUF_INIT;1238struct strbuf author_email = STRBUF_INIT;1239int ret =0;1240struct mailinfo mi;12411242setup_mailinfo(&mi);12431244if(state->utf8)1245 mi.metainfo_charset =get_commit_output_encoding();1246else1247 mi.metainfo_charset = NULL;12481249switch(state->keep) {1250case KEEP_FALSE:1251break;1252case KEEP_TRUE:1253 mi.keep_subject =1;1254break;1255case KEEP_NON_PATCH:1256 mi.keep_non_patch_brackets_in_subject =1;1257break;1258default:1259die("BUG: invalid value for state->keep");1260}12611262if(state->message_id)1263 mi.add_message_id =1;12641265switch(state->scissors) {1266case SCISSORS_UNSET:1267break;1268case SCISSORS_FALSE:1269 mi.use_scissors =0;1270break;1271case SCISSORS_TRUE:1272 mi.use_scissors =1;1273break;1274default:1275die("BUG: invalid value for state->scissors");1276}12771278 mi.input =fopen(mail,"r");1279if(!mi.input)1280die("could not open input");1281 mi.output =fopen(am_path(state,"info"),"w");1282if(!mi.output)1283die("could not open output 'info'");1284if(mailinfo(&mi,am_path(state,"msg"),am_path(state,"patch")))1285die("could not parse patch");12861287fclose(mi.input);1288fclose(mi.output);12891290/* Extract message and author information */1291 fp =xfopen(am_path(state,"info"),"r");1292while(!strbuf_getline_lf(&sb, fp)) {1293const char*x;12941295if(skip_prefix(sb.buf,"Subject: ", &x)) {1296if(msg.len)1297strbuf_addch(&msg,'\n');1298strbuf_addstr(&msg, x);1299}else if(skip_prefix(sb.buf,"Author: ", &x))1300strbuf_addstr(&author_name, x);1301else if(skip_prefix(sb.buf,"Email: ", &x))1302strbuf_addstr(&author_email, x);1303else if(skip_prefix(sb.buf,"Date: ", &x))1304strbuf_addstr(&author_date, x);1305}1306fclose(fp);13071308/* Skip pine's internal folder data */1309if(!strcmp(author_name.buf,"Mail System Internal Data")) {1310 ret =1;1311goto finish;1312}13131314if(is_empty_file(am_path(state,"patch"))) {1315printf_ln(_("Patch is empty. Was it split wrong?"));1316die_user_resolve(state);1317}13181319strbuf_addstr(&msg,"\n\n");1320strbuf_addbuf(&msg, &mi.log_message);1321strbuf_stripspace(&msg,0);13221323assert(!state->author_name);1324 state->author_name =strbuf_detach(&author_name, NULL);13251326assert(!state->author_email);1327 state->author_email =strbuf_detach(&author_email, NULL);13281329assert(!state->author_date);1330 state->author_date =strbuf_detach(&author_date, NULL);13311332assert(!state->msg);1333 state->msg =strbuf_detach(&msg, &state->msg_len);13341335finish:1336strbuf_release(&msg);1337strbuf_release(&author_date);1338strbuf_release(&author_email);1339strbuf_release(&author_name);1340strbuf_release(&sb);1341clear_mailinfo(&mi);1342return ret;1343}13441345/**1346 * Sets commit_id to the commit hash where the mail was generated from.1347 * Returns 0 on success, -1 on failure.1348 */1349static intget_mail_commit_oid(struct object_id *commit_id,const char*mail)1350{1351struct strbuf sb = STRBUF_INIT;1352FILE*fp =xfopen(mail,"r");1353const char*x;13541355if(strbuf_getline_lf(&sb, fp))1356return-1;13571358if(!skip_prefix(sb.buf,"From ", &x))1359return-1;13601361if(get_oid_hex(x, commit_id) <0)1362return-1;13631364strbuf_release(&sb);1365fclose(fp);1366return0;1367}13681369/**1370 * Sets state->msg, state->author_name, state->author_email, state->author_date1371 * to the commit's respective info.1372 */1373static voidget_commit_info(struct am_state *state,struct commit *commit)1374{1375const char*buffer, *ident_line, *author_date, *msg;1376size_t ident_len;1377struct ident_split ident_split;1378struct strbuf sb = STRBUF_INIT;13791380 buffer =logmsg_reencode(commit, NULL,get_commit_output_encoding());13811382 ident_line =find_commit_header(buffer,"author", &ident_len);13831384if(split_ident_line(&ident_split, ident_line, ident_len) <0) {1385strbuf_add(&sb, ident_line, ident_len);1386die(_("invalid ident line:%s"), sb.buf);1387}13881389assert(!state->author_name);1390if(ident_split.name_begin) {1391strbuf_add(&sb, ident_split.name_begin,1392 ident_split.name_end - ident_split.name_begin);1393 state->author_name =strbuf_detach(&sb, NULL);1394}else1395 state->author_name =xstrdup("");13961397assert(!state->author_email);1398if(ident_split.mail_begin) {1399strbuf_add(&sb, ident_split.mail_begin,1400 ident_split.mail_end - ident_split.mail_begin);1401 state->author_email =strbuf_detach(&sb, NULL);1402}else1403 state->author_email =xstrdup("");14041405 author_date =show_ident_date(&ident_split,DATE_MODE(NORMAL));1406strbuf_addstr(&sb, author_date);1407assert(!state->author_date);1408 state->author_date =strbuf_detach(&sb, NULL);14091410assert(!state->msg);1411 msg =strstr(buffer,"\n\n");1412if(!msg)1413die(_("unable to parse commit%s"),oid_to_hex(&commit->object.oid));1414 state->msg =xstrdup(msg +2);1415 state->msg_len =strlen(state->msg);1416}14171418/**1419 * Writes `commit` as a patch to the state directory's "patch" file.1420 */1421static voidwrite_commit_patch(const struct am_state *state,struct commit *commit)1422{1423struct rev_info rev_info;1424FILE*fp;14251426 fp =xfopen(am_path(state,"patch"),"w");1427init_revisions(&rev_info, NULL);1428 rev_info.diff =1;1429 rev_info.abbrev =0;1430 rev_info.disable_stdin =1;1431 rev_info.show_root_diff =1;1432 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;1433 rev_info.no_commit_id =1;1434DIFF_OPT_SET(&rev_info.diffopt, BINARY);1435DIFF_OPT_SET(&rev_info.diffopt, FULL_INDEX);1436 rev_info.diffopt.use_color =0;1437 rev_info.diffopt.file = fp;1438 rev_info.diffopt.close_file =1;1439add_pending_object(&rev_info, &commit->object,"");1440diff_setup_done(&rev_info.diffopt);1441log_tree_commit(&rev_info, commit);1442}14431444/**1445 * Writes the diff of the index against HEAD as a patch to the state1446 * directory's "patch" file.1447 */1448static voidwrite_index_patch(const struct am_state *state)1449{1450struct tree *tree;1451struct object_id head;1452struct rev_info rev_info;1453FILE*fp;14541455if(!get_sha1_tree("HEAD", head.hash))1456 tree =lookup_tree(&head);1457else1458 tree =lookup_tree(&empty_tree_oid);14591460 fp =xfopen(am_path(state,"patch"),"w");1461init_revisions(&rev_info, NULL);1462 rev_info.diff =1;1463 rev_info.disable_stdin =1;1464 rev_info.no_commit_id =1;1465 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;1466 rev_info.diffopt.use_color =0;1467 rev_info.diffopt.file = fp;1468 rev_info.diffopt.close_file =1;1469add_pending_object(&rev_info, &tree->object,"");1470diff_setup_done(&rev_info.diffopt);1471run_diff_index(&rev_info,1);1472}14731474/**1475 * Like parse_mail(), but parses the mail by looking up its commit ID1476 * directly. This is used in --rebasing mode to bypass git-mailinfo's munging1477 * of patches.1478 *1479 * state->orig_commit will be set to the original commit ID.1480 *1481 * Will always return 0 as the patch should never be skipped.1482 */1483static intparse_mail_rebase(struct am_state *state,const char*mail)1484{1485struct commit *commit;1486struct object_id commit_oid;14871488if(get_mail_commit_oid(&commit_oid, mail) <0)1489die(_("could not parse%s"), mail);14901491 commit =lookup_commit_or_die(&commit_oid, mail);14921493get_commit_info(state, commit);14941495write_commit_patch(state, commit);14961497oidcpy(&state->orig_commit, &commit_oid);1498write_state_text(state,"original-commit",oid_to_hex(&commit_oid));14991500return0;1501}15021503/**1504 * Applies current patch with git-apply. Returns 0 on success, -1 otherwise. If1505 * `index_file` is not NULL, the patch will be applied to that index.1506 */1507static intrun_apply(const struct am_state *state,const char*index_file)1508{1509struct argv_array apply_paths = ARGV_ARRAY_INIT;1510struct argv_array apply_opts = ARGV_ARRAY_INIT;1511struct apply_state apply_state;1512int res, opts_left;1513static struct lock_file lock_file;1514int force_apply =0;1515int options =0;15161517if(init_apply_state(&apply_state, NULL, &lock_file))1518die("BUG: init_apply_state() failed");15191520argv_array_push(&apply_opts,"apply");1521argv_array_pushv(&apply_opts, state->git_apply_opts.argv);15221523 opts_left =apply_parse_options(apply_opts.argc, apply_opts.argv,1524&apply_state, &force_apply, &options,1525 NULL);15261527if(opts_left !=0)1528die("unknown option passed through to git apply");15291530if(index_file) {1531 apply_state.index_file = index_file;1532 apply_state.cached =1;1533}else1534 apply_state.check_index =1;15351536/*1537 * If we are allowed to fall back on 3-way merge, don't give false1538 * errors during the initial attempt.1539 */1540if(state->threeway && !index_file)1541 apply_state.apply_verbosity = verbosity_silent;15421543if(check_apply_state(&apply_state, force_apply))1544die("BUG: check_apply_state() failed");15451546argv_array_push(&apply_paths,am_path(state,"patch"));15471548 res =apply_all_patches(&apply_state, apply_paths.argc, apply_paths.argv, options);15491550argv_array_clear(&apply_paths);1551argv_array_clear(&apply_opts);1552clear_apply_state(&apply_state);15531554if(res)1555return res;15561557if(index_file) {1558/* Reload index as apply_all_patches() will have modified it. */1559discard_cache();1560read_cache_from(index_file);1561}15621563return0;1564}15651566/**1567 * Builds an index that contains just the blobs needed for a 3way merge.1568 */1569static intbuild_fake_ancestor(const struct am_state *state,const char*index_file)1570{1571struct child_process cp = CHILD_PROCESS_INIT;15721573 cp.git_cmd =1;1574argv_array_push(&cp.args,"apply");1575argv_array_pushv(&cp.args, state->git_apply_opts.argv);1576argv_array_pushf(&cp.args,"--build-fake-ancestor=%s", index_file);1577argv_array_push(&cp.args,am_path(state,"patch"));15781579if(run_command(&cp))1580return-1;15811582return0;1583}15841585/**1586 * Attempt a threeway merge, using index_path as the temporary index.1587 */1588static intfall_back_threeway(const struct am_state *state,const char*index_path)1589{1590struct object_id orig_tree, their_tree, our_tree;1591const struct object_id *bases[1] = { &orig_tree };1592struct merge_options o;1593struct commit *result;1594char*their_tree_name;15951596if(get_oid("HEAD", &our_tree) <0)1597hashcpy(our_tree.hash, EMPTY_TREE_SHA1_BIN);15981599if(build_fake_ancestor(state, index_path))1600returnerror("could not build fake ancestor");16011602discard_cache();1603read_cache_from(index_path);16041605if(write_index_as_tree(orig_tree.hash, &the_index, index_path,0, NULL))1606returnerror(_("Repository lacks necessary blobs to fall back on 3-way merge."));16071608say(state, stdout,_("Using index info to reconstruct a base tree..."));16091610if(!state->quiet) {1611/*1612 * List paths that needed 3-way fallback, so that the user can1613 * review them with extra care to spot mismerges.1614 */1615struct rev_info rev_info;1616const char*diff_filter_str ="--diff-filter=AM";16171618init_revisions(&rev_info, NULL);1619 rev_info.diffopt.output_format = DIFF_FORMAT_NAME_STATUS;1620diff_opt_parse(&rev_info.diffopt, &diff_filter_str,1, rev_info.prefix);1621add_pending_oid(&rev_info,"HEAD", &our_tree,0);1622diff_setup_done(&rev_info.diffopt);1623run_diff_index(&rev_info,1);1624}16251626if(run_apply(state, index_path))1627returnerror(_("Did you hand edit your patch?\n"1628"It does not apply to blobs recorded in its index."));16291630if(write_index_as_tree(their_tree.hash, &the_index, index_path,0, NULL))1631returnerror("could not write tree");16321633say(state, stdout,_("Falling back to patching base and 3-way merge..."));16341635discard_cache();1636read_cache();16371638/*1639 * This is not so wrong. Depending on which base we picked, orig_tree1640 * may be wildly different from ours, but their_tree has the same set of1641 * wildly different changes in parts the patch did not touch, so1642 * recursive ends up canceling them, saying that we reverted all those1643 * changes.1644 */16451646init_merge_options(&o);16471648 o.branch1 ="HEAD";1649 their_tree_name =xstrfmt("%.*s",linelen(state->msg), state->msg);1650 o.branch2 = their_tree_name;16511652if(state->quiet)1653 o.verbosity =0;16541655if(merge_recursive_generic(&o, &our_tree, &their_tree,1, bases, &result)) {1656rerere(state->allow_rerere_autoupdate);1657free(their_tree_name);1658returnerror(_("Failed to merge in the changes."));1659}16601661free(their_tree_name);1662return0;1663}16641665/**1666 * Commits the current index with state->msg as the commit message and1667 * state->author_name, state->author_email and state->author_date as the author1668 * information.1669 */1670static voiddo_commit(const struct am_state *state)1671{1672struct object_id tree, parent, commit;1673const struct object_id *old_oid;1674struct commit_list *parents = NULL;1675const char*reflog_msg, *author;1676struct strbuf sb = STRBUF_INIT;16771678if(run_hook_le(NULL,"pre-applypatch", NULL))1679exit(1);16801681if(write_cache_as_tree(tree.hash,0, NULL))1682die(_("git write-tree failed to write a tree"));16831684if(!get_sha1_commit("HEAD", parent.hash)) {1685 old_oid = &parent;1686commit_list_insert(lookup_commit(&parent), &parents);1687}else{1688 old_oid = NULL;1689say(state, stderr,_("applying to an empty history"));1690}16911692 author =fmt_ident(state->author_name, state->author_email,1693 state->ignore_date ? NULL : state->author_date,1694 IDENT_STRICT);16951696if(state->committer_date_is_author_date)1697setenv("GIT_COMMITTER_DATE",1698 state->ignore_date ?"": state->author_date,1);16991700if(commit_tree(state->msg, state->msg_len, tree.hash, parents, commit.hash,1701 author, state->sign_commit))1702die(_("failed to write commit object"));17031704 reflog_msg =getenv("GIT_REFLOG_ACTION");1705if(!reflog_msg)1706 reflog_msg ="am";17071708strbuf_addf(&sb,"%s: %.*s", reflog_msg,linelen(state->msg),1709 state->msg);17101711update_ref_oid(sb.buf,"HEAD", &commit, old_oid,0,1712 UPDATE_REFS_DIE_ON_ERR);17131714if(state->rebasing) {1715FILE*fp =xfopen(am_path(state,"rewritten"),"a");17161717assert(!is_null_oid(&state->orig_commit));1718fprintf(fp,"%s",oid_to_hex(&state->orig_commit));1719fprintf(fp,"%s\n",oid_to_hex(&commit));1720fclose(fp);1721}17221723run_hook_le(NULL,"post-applypatch", NULL);17241725strbuf_release(&sb);1726}17271728/**1729 * Validates the am_state for resuming -- the "msg" and authorship fields must1730 * be filled up.1731 */1732static voidvalidate_resume_state(const struct am_state *state)1733{1734if(!state->msg)1735die(_("cannot resume:%sdoes not exist."),1736am_path(state,"final-commit"));17371738if(!state->author_name || !state->author_email || !state->author_date)1739die(_("cannot resume:%sdoes not exist."),1740am_path(state,"author-script"));1741}17421743/**1744 * Interactively prompt the user on whether the current patch should be1745 * applied.1746 *1747 * Returns 0 if the user chooses to apply the patch, 1 if the user chooses to1748 * skip it.1749 */1750static intdo_interactive(struct am_state *state)1751{1752assert(state->msg);17531754if(!isatty(0))1755die(_("cannot be interactive without stdin connected to a terminal."));17561757for(;;) {1758const char*reply;17591760puts(_("Commit Body is:"));1761puts("--------------------------");1762printf("%s", state->msg);1763puts("--------------------------");17641765/*1766 * TRANSLATORS: Make sure to include [y], [n], [e], [v] and [a]1767 * in your translation. The program will only accept English1768 * input at this point.1769 */1770 reply =git_prompt(_("Apply? [y]es/[n]o/[e]dit/[v]iew patch/[a]ccept all: "), PROMPT_ECHO);17711772if(!reply) {1773continue;1774}else if(*reply =='y'|| *reply =='Y') {1775return0;1776}else if(*reply =='a'|| *reply =='A') {1777 state->interactive =0;1778return0;1779}else if(*reply =='n'|| *reply =='N') {1780return1;1781}else if(*reply =='e'|| *reply =='E') {1782struct strbuf msg = STRBUF_INIT;17831784if(!launch_editor(am_path(state,"final-commit"), &msg, NULL)) {1785free(state->msg);1786 state->msg =strbuf_detach(&msg, &state->msg_len);1787}1788strbuf_release(&msg);1789}else if(*reply =='v'|| *reply =='V') {1790const char*pager =git_pager(1);1791struct child_process cp = CHILD_PROCESS_INIT;17921793if(!pager)1794 pager ="cat";1795prepare_pager_args(&cp, pager);1796argv_array_push(&cp.args,am_path(state,"patch"));1797run_command(&cp);1798}1799}1800}18011802/**1803 * Applies all queued mail.1804 *1805 * If `resume` is true, we are "resuming". The "msg" and authorship fields, as1806 * well as the state directory's "patch" file is used as-is for applying the1807 * patch and committing it.1808 */1809static voidam_run(struct am_state *state,int resume)1810{1811const char*argv_gc_auto[] = {"gc","--auto", NULL};1812struct strbuf sb = STRBUF_INIT;18131814unlink(am_path(state,"dirtyindex"));18151816refresh_and_write_cache();18171818if(index_has_changes(&sb)) {1819write_state_bool(state,"dirtyindex",1);1820die(_("Dirty index: cannot apply patches (dirty:%s)"), sb.buf);1821}18221823strbuf_release(&sb);18241825while(state->cur <= state->last) {1826const char*mail =am_path(state,msgnum(state));1827int apply_status;18281829reset_ident_date();18301831if(!file_exists(mail))1832goto next;18331834if(resume) {1835validate_resume_state(state);1836}else{1837int skip;18381839if(state->rebasing)1840 skip =parse_mail_rebase(state, mail);1841else1842 skip =parse_mail(state, mail);18431844if(skip)1845goto next;/* mail should be skipped */18461847if(state->signoff)1848am_append_signoff(state);18491850write_author_script(state);1851write_commit_msg(state);1852}18531854if(state->interactive &&do_interactive(state))1855goto next;18561857if(run_applypatch_msg_hook(state))1858exit(1);18591860say(state, stdout,_("Applying: %.*s"),linelen(state->msg), state->msg);18611862 apply_status =run_apply(state, NULL);18631864if(apply_status && state->threeway) {1865struct strbuf sb = STRBUF_INIT;18661867strbuf_addstr(&sb,am_path(state,"patch-merge-index"));1868 apply_status =fall_back_threeway(state, sb.buf);1869strbuf_release(&sb);18701871/*1872 * Applying the patch to an earlier tree and merging1873 * the result may have produced the same tree as ours.1874 */1875if(!apply_status && !index_has_changes(NULL)) {1876say(state, stdout,_("No changes -- Patch already applied."));1877goto next;1878}1879}18801881if(apply_status) {1882int advice_amworkdir =1;18831884printf_ln(_("Patch failed at%s%.*s"),msgnum(state),1885linelen(state->msg), state->msg);18861887git_config_get_bool("advice.amworkdir", &advice_amworkdir);18881889if(advice_amworkdir)1890printf_ln(_("The copy of the patch that failed is found in:%s"),1891am_path(state,"patch"));18921893die_user_resolve(state);1894}18951896do_commit(state);18971898next:1899am_next(state);19001901if(resume)1902am_load(state);1903 resume =0;1904}19051906if(!is_empty_file(am_path(state,"rewritten"))) {1907assert(state->rebasing);1908copy_notes_for_rebase(state);1909run_post_rewrite_hook(state);1910}19111912/*1913 * In rebasing mode, it's up to the caller to take care of1914 * housekeeping.1915 */1916if(!state->rebasing) {1917am_destroy(state);1918close_all_packs();1919run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);1920}1921}19221923/**1924 * Resume the current am session after patch application failure. The user did1925 * all the hard work, and we do not have to do any patch application. Just1926 * trust and commit what the user has in the index and working tree.1927 */1928static voidam_resolve(struct am_state *state)1929{1930validate_resume_state(state);19311932say(state, stdout,_("Applying: %.*s"),linelen(state->msg), state->msg);19331934if(!index_has_changes(NULL)) {1935printf_ln(_("No changes - did you forget to use 'git add'?\n"1936"If there is nothing left to stage, chances are that something else\n"1937"already introduced the same changes; you might want to skip this patch."));1938die_user_resolve(state);1939}19401941if(unmerged_cache()) {1942printf_ln(_("You still have unmerged paths in your index.\n"1943"Did you forget to use 'git add'?"));1944die_user_resolve(state);1945}19461947if(state->interactive) {1948write_index_patch(state);1949if(do_interactive(state))1950goto next;1951}19521953rerere(0);19541955do_commit(state);19561957next:1958am_next(state);1959am_load(state);1960am_run(state,0);1961}19621963/**1964 * Performs a checkout fast-forward from `head` to `remote`. If `reset` is1965 * true, any unmerged entries will be discarded. Returns 0 on success, -1 on1966 * failure.1967 */1968static intfast_forward_to(struct tree *head,struct tree *remote,int reset)1969{1970struct lock_file *lock_file;1971struct unpack_trees_options opts;1972struct tree_desc t[2];19731974if(parse_tree(head) ||parse_tree(remote))1975return-1;19761977 lock_file =xcalloc(1,sizeof(struct lock_file));1978hold_locked_index(lock_file, LOCK_DIE_ON_ERROR);19791980refresh_cache(REFRESH_QUIET);19811982memset(&opts,0,sizeof(opts));1983 opts.head_idx =1;1984 opts.src_index = &the_index;1985 opts.dst_index = &the_index;1986 opts.update =1;1987 opts.merge =1;1988 opts.reset = reset;1989 opts.fn = twoway_merge;1990init_tree_desc(&t[0], head->buffer, head->size);1991init_tree_desc(&t[1], remote->buffer, remote->size);19921993if(unpack_trees(2, t, &opts)) {1994rollback_lock_file(lock_file);1995return-1;1996}19971998if(write_locked_index(&the_index, lock_file, COMMIT_LOCK))1999die(_("unable to write new index file"));20002001return0;2002}20032004/**2005 * Merges a tree into the index. The index's stat info will take precedence2006 * over the merged tree's. Returns 0 on success, -1 on failure.2007 */2008static intmerge_tree(struct tree *tree)2009{2010struct lock_file *lock_file;2011struct unpack_trees_options opts;2012struct tree_desc t[1];20132014if(parse_tree(tree))2015return-1;20162017 lock_file =xcalloc(1,sizeof(struct lock_file));2018hold_locked_index(lock_file, LOCK_DIE_ON_ERROR);20192020memset(&opts,0,sizeof(opts));2021 opts.head_idx =1;2022 opts.src_index = &the_index;2023 opts.dst_index = &the_index;2024 opts.merge =1;2025 opts.fn = oneway_merge;2026init_tree_desc(&t[0], tree->buffer, tree->size);20272028if(unpack_trees(1, t, &opts)) {2029rollback_lock_file(lock_file);2030return-1;2031}20322033if(write_locked_index(&the_index, lock_file, COMMIT_LOCK))2034die(_("unable to write new index file"));20352036return0;2037}20382039/**2040 * Clean the index without touching entries that are not modified between2041 * `head` and `remote`.2042 */2043static intclean_index(const struct object_id *head,const struct object_id *remote)2044{2045struct tree *head_tree, *remote_tree, *index_tree;2046struct object_id index;20472048 head_tree =parse_tree_indirect(head->hash);2049if(!head_tree)2050returnerror(_("Could not parse object '%s'."),oid_to_hex(head));20512052 remote_tree =parse_tree_indirect(remote->hash);2053if(!remote_tree)2054returnerror(_("Could not parse object '%s'."),oid_to_hex(remote));20552056read_cache_unmerged();20572058if(fast_forward_to(head_tree, head_tree,1))2059return-1;20602061if(write_cache_as_tree(index.hash,0, NULL))2062return-1;20632064 index_tree =parse_tree_indirect(index.hash);2065if(!index_tree)2066returnerror(_("Could not parse object '%s'."),oid_to_hex(&index));20672068if(fast_forward_to(index_tree, remote_tree,0))2069return-1;20702071if(merge_tree(remote_tree))2072return-1;20732074remove_branch_state();20752076return0;2077}20782079/**2080 * Resets rerere's merge resolution metadata.2081 */2082static voidam_rerere_clear(void)2083{2084struct string_list merge_rr = STRING_LIST_INIT_DUP;2085rerere_clear(&merge_rr);2086string_list_clear(&merge_rr,1);2087}20882089/**2090 * Resume the current am session by skipping the current patch.2091 */2092static voidam_skip(struct am_state *state)2093{2094struct object_id head;20952096am_rerere_clear();20972098if(get_oid("HEAD", &head))2099hashcpy(head.hash, EMPTY_TREE_SHA1_BIN);21002101if(clean_index(&head, &head))2102die(_("failed to clean index"));21032104am_next(state);2105am_load(state);2106am_run(state,0);2107}21082109/**2110 * Returns true if it is safe to reset HEAD to the ORIG_HEAD, false otherwise.2111 *2112 * It is not safe to reset HEAD when:2113 * 1. git-am previously failed because the index was dirty.2114 * 2. HEAD has moved since git-am previously failed.2115 */2116static intsafe_to_abort(const struct am_state *state)2117{2118struct strbuf sb = STRBUF_INIT;2119struct object_id abort_safety, head;21202121if(file_exists(am_path(state,"dirtyindex")))2122return0;21232124if(read_state_file(&sb, state,"abort-safety",1) >0) {2125if(get_oid_hex(sb.buf, &abort_safety))2126die(_("could not parse%s"),am_path(state,"abort-safety"));2127}else2128oidclr(&abort_safety);21292130if(get_oid("HEAD", &head))2131oidclr(&head);21322133if(!oidcmp(&head, &abort_safety))2134return1;21352136warning(_("You seem to have moved HEAD since the last 'am' failure.\n"2137"Not rewinding to ORIG_HEAD"));21382139return0;2140}21412142/**2143 * Aborts the current am session if it is safe to do so.2144 */2145static voidam_abort(struct am_state *state)2146{2147struct object_id curr_head, orig_head;2148int has_curr_head, has_orig_head;2149char*curr_branch;21502151if(!safe_to_abort(state)) {2152am_destroy(state);2153return;2154}21552156am_rerere_clear();21572158 curr_branch =resolve_refdup("HEAD",0, curr_head.hash, NULL);2159 has_curr_head = !is_null_oid(&curr_head);2160if(!has_curr_head)2161hashcpy(curr_head.hash, EMPTY_TREE_SHA1_BIN);21622163 has_orig_head = !get_oid("ORIG_HEAD", &orig_head);2164if(!has_orig_head)2165hashcpy(orig_head.hash, EMPTY_TREE_SHA1_BIN);21662167clean_index(&curr_head, &orig_head);21682169if(has_orig_head)2170update_ref_oid("am --abort","HEAD", &orig_head,2171 has_curr_head ? &curr_head : NULL,0,2172 UPDATE_REFS_DIE_ON_ERR);2173else if(curr_branch)2174delete_ref(NULL, curr_branch, NULL, REF_NODEREF);21752176free(curr_branch);2177am_destroy(state);2178}21792180/**2181 * parse_options() callback that validates and sets opt->value to the2182 * PATCH_FORMAT_* enum value corresponding to `arg`.2183 */2184static intparse_opt_patchformat(const struct option *opt,const char*arg,int unset)2185{2186int*opt_value = opt->value;21872188if(!strcmp(arg,"mbox"))2189*opt_value = PATCH_FORMAT_MBOX;2190else if(!strcmp(arg,"stgit"))2191*opt_value = PATCH_FORMAT_STGIT;2192else if(!strcmp(arg,"stgit-series"))2193*opt_value = PATCH_FORMAT_STGIT_SERIES;2194else if(!strcmp(arg,"hg"))2195*opt_value = PATCH_FORMAT_HG;2196else if(!strcmp(arg,"mboxrd"))2197*opt_value = PATCH_FORMAT_MBOXRD;2198else2199returnerror(_("Invalid value for --patch-format:%s"), arg);2200return0;2201}22022203enum resume_mode {2204 RESUME_FALSE =0,2205 RESUME_APPLY,2206 RESUME_RESOLVED,2207 RESUME_SKIP,2208 RESUME_ABORT2209};22102211static intgit_am_config(const char*k,const char*v,void*cb)2212{2213int status;22142215 status =git_gpg_config(k, v, NULL);2216if(status)2217return status;22182219returngit_default_config(k, v, NULL);2220}22212222intcmd_am(int argc,const char**argv,const char*prefix)2223{2224struct am_state state;2225int binary = -1;2226int keep_cr = -1;2227int patch_format = PATCH_FORMAT_UNKNOWN;2228enum resume_mode resume = RESUME_FALSE;2229int in_progress;22302231const char*const usage[] = {2232N_("git am [<options>] [(<mbox> | <Maildir>)...]"),2233N_("git am [<options>] (--continue | --skip | --abort)"),2234 NULL2235};22362237struct option options[] = {2238OPT_BOOL('i',"interactive", &state.interactive,2239N_("run interactively")),2240OPT_HIDDEN_BOOL('b',"binary", &binary,2241N_("historical option -- no-op")),2242OPT_BOOL('3',"3way", &state.threeway,2243N_("allow fall back on 3way merging if needed")),2244OPT__QUIET(&state.quiet,N_("be quiet")),2245OPT_SET_INT('s',"signoff", &state.signoff,2246N_("add a Signed-off-by line to the commit message"),2247 SIGNOFF_EXPLICIT),2248OPT_BOOL('u',"utf8", &state.utf8,2249N_("recode into utf8 (default)")),2250OPT_SET_INT('k',"keep", &state.keep,2251N_("pass -k flag to git-mailinfo"), KEEP_TRUE),2252OPT_SET_INT(0,"keep-non-patch", &state.keep,2253N_("pass -b flag to git-mailinfo"), KEEP_NON_PATCH),2254OPT_BOOL('m',"message-id", &state.message_id,2255N_("pass -m flag to git-mailinfo")),2256{ OPTION_SET_INT,0,"keep-cr", &keep_cr, NULL,2257N_("pass --keep-cr flag to git-mailsplit for mbox format"),2258 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},2259{ OPTION_SET_INT,0,"no-keep-cr", &keep_cr, NULL,2260N_("do not pass --keep-cr flag to git-mailsplit independent of am.keepcr"),2261 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,0},2262OPT_BOOL('c',"scissors", &state.scissors,2263N_("strip everything before a scissors line")),2264OPT_PASSTHRU_ARGV(0,"whitespace", &state.git_apply_opts,N_("action"),2265N_("pass it through git-apply"),22660),2267OPT_PASSTHRU_ARGV(0,"ignore-space-change", &state.git_apply_opts, NULL,2268N_("pass it through git-apply"),2269 PARSE_OPT_NOARG),2270OPT_PASSTHRU_ARGV(0,"ignore-whitespace", &state.git_apply_opts, NULL,2271N_("pass it through git-apply"),2272 PARSE_OPT_NOARG),2273OPT_PASSTHRU_ARGV(0,"directory", &state.git_apply_opts,N_("root"),2274N_("pass it through git-apply"),22750),2276OPT_PASSTHRU_ARGV(0,"exclude", &state.git_apply_opts,N_("path"),2277N_("pass it through git-apply"),22780),2279OPT_PASSTHRU_ARGV(0,"include", &state.git_apply_opts,N_("path"),2280N_("pass it through git-apply"),22810),2282OPT_PASSTHRU_ARGV('C', NULL, &state.git_apply_opts,N_("n"),2283N_("pass it through git-apply"),22840),2285OPT_PASSTHRU_ARGV('p', NULL, &state.git_apply_opts,N_("num"),2286N_("pass it through git-apply"),22870),2288OPT_CALLBACK(0,"patch-format", &patch_format,N_("format"),2289N_("format the patch(es) are in"),2290 parse_opt_patchformat),2291OPT_PASSTHRU_ARGV(0,"reject", &state.git_apply_opts, NULL,2292N_("pass it through git-apply"),2293 PARSE_OPT_NOARG),2294OPT_STRING(0,"resolvemsg", &state.resolvemsg, NULL,2295N_("override error message when patch failure occurs")),2296OPT_CMDMODE(0,"continue", &resume,2297N_("continue applying patches after resolving a conflict"),2298 RESUME_RESOLVED),2299OPT_CMDMODE('r',"resolved", &resume,2300N_("synonyms for --continue"),2301 RESUME_RESOLVED),2302OPT_CMDMODE(0,"skip", &resume,2303N_("skip the current patch"),2304 RESUME_SKIP),2305OPT_CMDMODE(0,"abort", &resume,2306N_("restore the original branch and abort the patching operation."),2307 RESUME_ABORT),2308OPT_BOOL(0,"committer-date-is-author-date",2309&state.committer_date_is_author_date,2310N_("lie about committer date")),2311OPT_BOOL(0,"ignore-date", &state.ignore_date,2312N_("use current timestamp for author date")),2313OPT_RERERE_AUTOUPDATE(&state.allow_rerere_autoupdate),2314{ OPTION_STRING,'S',"gpg-sign", &state.sign_commit,N_("key-id"),2315N_("GPG-sign commits"),2316 PARSE_OPT_OPTARG, NULL, (intptr_t)""},2317OPT_HIDDEN_BOOL(0,"rebasing", &state.rebasing,2318N_("(internal use for git-rebase)")),2319OPT_END()2320};23212322git_config(git_am_config, NULL);23232324am_state_init(&state);23252326 in_progress =am_in_progress(&state);2327if(in_progress)2328am_load(&state);23292330 argc =parse_options(argc, argv, prefix, options, usage,0);23312332if(binary >=0)2333fprintf_ln(stderr,_("The -b/--binary option has been a no-op for long time, and\n"2334"it will be removed. Please do not use it anymore."));23352336/* Ensure a valid committer ident can be constructed */2337git_committer_info(IDENT_STRICT);23382339if(read_index_preload(&the_index, NULL) <0)2340die(_("failed to read the index"));23412342if(in_progress) {2343/*2344 * Catch user error to feed us patches when there is a session2345 * in progress:2346 *2347 * 1. mbox path(s) are provided on the command-line.2348 * 2. stdin is not a tty: the user is trying to feed us a patch2349 * from standard input. This is somewhat unreliable -- stdin2350 * could be /dev/null for example and the caller did not2351 * intend to feed us a patch but wanted to continue2352 * unattended.2353 */2354if(argc || (resume == RESUME_FALSE && !isatty(0)))2355die(_("previous rebase directory%sstill exists but mbox given."),2356 state.dir);23572358if(resume == RESUME_FALSE)2359 resume = RESUME_APPLY;23602361if(state.signoff == SIGNOFF_EXPLICIT)2362am_append_signoff(&state);2363}else{2364struct argv_array paths = ARGV_ARRAY_INIT;2365int i;23662367/*2368 * Handle stray state directory in the independent-run case. In2369 * the --rebasing case, it is up to the caller to take care of2370 * stray directories.2371 */2372if(file_exists(state.dir) && !state.rebasing) {2373if(resume == RESUME_ABORT) {2374am_destroy(&state);2375am_state_release(&state);2376return0;2377}23782379die(_("Stray%sdirectory found.\n"2380"Use\"git am --abort\"to remove it."),2381 state.dir);2382}23832384if(resume)2385die(_("Resolve operation not in progress, we are not resuming."));23862387for(i =0; i < argc; i++) {2388if(is_absolute_path(argv[i]) || !prefix)2389argv_array_push(&paths, argv[i]);2390else2391argv_array_push(&paths,mkpath("%s/%s", prefix, argv[i]));2392}23932394am_setup(&state, patch_format, paths.argv, keep_cr);23952396argv_array_clear(&paths);2397}23982399switch(resume) {2400case RESUME_FALSE:2401am_run(&state,0);2402break;2403case RESUME_APPLY:2404am_run(&state,1);2405break;2406case RESUME_RESOLVED:2407am_resolve(&state);2408break;2409case RESUME_SKIP:2410am_skip(&state);2411break;2412case RESUME_ABORT:2413am_abort(&state);2414break;2415default:2416die("BUG: invalid resume value");2417}24182419am_state_release(&state);24202421return0;2422}