1/* 2 * Builtin "git am" 3 * 4 * Based on git-am.sh by Junio C Hamano. 5 */ 6#include"cache.h" 7#include"config.h" 8#include"builtin.h" 9#include"exec-cmd.h" 10#include"parse-options.h" 11#include"dir.h" 12#include"run-command.h" 13#include"quote.h" 14#include"tempfile.h" 15#include"lockfile.h" 16#include"cache-tree.h" 17#include"refs.h" 18#include"commit.h" 19#include"diff.h" 20#include"diffcore.h" 21#include"unpack-trees.h" 22#include"branch.h" 23#include"sequencer.h" 24#include"revision.h" 25#include"merge-recursive.h" 26#include"revision.h" 27#include"log-tree.h" 28#include"notes-utils.h" 29#include"rerere.h" 30#include"prompt.h" 31#include"mailinfo.h" 32#include"apply.h" 33#include"string-list.h" 34#include"packfile.h" 35#include"repository.h" 36 37/** 38 * Returns 1 if the file is empty or does not exist, 0 otherwise. 39 */ 40static intis_empty_file(const char*filename) 41{ 42struct stat st; 43 44if(stat(filename, &st) <0) { 45if(errno == ENOENT) 46return1; 47die_errno(_("could not stat%s"), filename); 48} 49 50return!st.st_size; 51} 52 53/** 54 * Returns the length of the first line of msg. 55 */ 56static intlinelen(const char*msg) 57{ 58returnstrchrnul(msg,'\n') - msg; 59} 60 61/** 62 * Returns true if `str` consists of only whitespace, false otherwise. 63 */ 64static intstr_isspace(const char*str) 65{ 66for(; *str; str++) 67if(!isspace(*str)) 68return0; 69 70return1; 71} 72 73enum patch_format { 74 PATCH_FORMAT_UNKNOWN =0, 75 PATCH_FORMAT_MBOX, 76 PATCH_FORMAT_STGIT, 77 PATCH_FORMAT_STGIT_SERIES, 78 PATCH_FORMAT_HG, 79 PATCH_FORMAT_MBOXRD 80}; 81 82enum keep_type { 83 KEEP_FALSE =0, 84 KEEP_TRUE,/* pass -k flag to git-mailinfo */ 85 KEEP_NON_PATCH /* pass -b flag to git-mailinfo */ 86}; 87 88enum scissors_type { 89 SCISSORS_UNSET = -1, 90 SCISSORS_FALSE =0,/* pass --no-scissors to git-mailinfo */ 91 SCISSORS_TRUE /* pass --scissors to git-mailinfo */ 92}; 93 94enum signoff_type { 95 SIGNOFF_FALSE =0, 96 SIGNOFF_TRUE =1, 97 SIGNOFF_EXPLICIT /* --signoff was set on the command-line */ 98}; 99 100struct am_state { 101/* state directory path */ 102char*dir; 103 104/* current and last patch numbers, 1-indexed */ 105int cur; 106int last; 107 108/* commit metadata and message */ 109char*author_name; 110char*author_email; 111char*author_date; 112char*msg; 113size_t msg_len; 114 115/* when --rebasing, records the original commit the patch came from */ 116struct object_id orig_commit; 117 118/* number of digits in patch filename */ 119int prec; 120 121/* various operating modes and command line options */ 122int interactive; 123int threeway; 124int quiet; 125int signoff;/* enum signoff_type */ 126int utf8; 127int keep;/* enum keep_type */ 128int message_id; 129int scissors;/* enum scissors_type */ 130struct argv_array git_apply_opts; 131const char*resolvemsg; 132int committer_date_is_author_date; 133int ignore_date; 134int allow_rerere_autoupdate; 135const char*sign_commit; 136int rebasing; 137}; 138 139/** 140 * Initializes am_state with the default values. 141 */ 142static voidam_state_init(struct am_state *state) 143{ 144int gpgsign; 145 146memset(state,0,sizeof(*state)); 147 148 state->dir =git_pathdup("rebase-apply"); 149 150 state->prec =4; 151 152git_config_get_bool("am.threeway", &state->threeway); 153 154 state->utf8 =1; 155 156git_config_get_bool("am.messageid", &state->message_id); 157 158 state->scissors = SCISSORS_UNSET; 159 160argv_array_init(&state->git_apply_opts); 161 162if(!git_config_get_bool("commit.gpgsign", &gpgsign)) 163 state->sign_commit = gpgsign ?"": NULL; 164} 165 166/** 167 * Releases memory allocated by an am_state. 168 */ 169static voidam_state_release(struct am_state *state) 170{ 171free(state->dir); 172free(state->author_name); 173free(state->author_email); 174free(state->author_date); 175free(state->msg); 176argv_array_clear(&state->git_apply_opts); 177} 178 179/** 180 * Returns path relative to the am_state directory. 181 */ 182staticinlineconst char*am_path(const struct am_state *state,const char*path) 183{ 184returnmkpath("%s/%s", state->dir, path); 185} 186 187/** 188 * For convenience to call write_file() 189 */ 190static voidwrite_state_text(const struct am_state *state, 191const char*name,const char*string) 192{ 193write_file(am_path(state, name),"%s", string); 194} 195 196static voidwrite_state_count(const struct am_state *state, 197const char*name,int value) 198{ 199write_file(am_path(state, name),"%d", value); 200} 201 202static voidwrite_state_bool(const struct am_state *state, 203const char*name,int value) 204{ 205write_state_text(state, name, value ?"t":"f"); 206} 207 208/** 209 * If state->quiet is false, calls fprintf(fp, fmt, ...), and appends a newline 210 * at the end. 211 */ 212static voidsay(const struct am_state *state,FILE*fp,const char*fmt, ...) 213{ 214va_list ap; 215 216va_start(ap, fmt); 217if(!state->quiet) { 218vfprintf(fp, fmt, ap); 219putc('\n', fp); 220} 221va_end(ap); 222} 223 224/** 225 * Returns 1 if there is an am session in progress, 0 otherwise. 226 */ 227static intam_in_progress(const struct am_state *state) 228{ 229struct stat st; 230 231if(lstat(state->dir, &st) <0|| !S_ISDIR(st.st_mode)) 232return0; 233if(lstat(am_path(state,"last"), &st) || !S_ISREG(st.st_mode)) 234return0; 235if(lstat(am_path(state,"next"), &st) || !S_ISREG(st.st_mode)) 236return0; 237return1; 238} 239 240/** 241 * Reads the contents of `file` in the `state` directory into `sb`. Returns the 242 * number of bytes read on success, -1 if the file does not exist. If `trim` is 243 * set, trailing whitespace will be removed. 244 */ 245static intread_state_file(struct strbuf *sb,const struct am_state *state, 246const char*file,int trim) 247{ 248strbuf_reset(sb); 249 250if(strbuf_read_file(sb,am_path(state, file),0) >=0) { 251if(trim) 252strbuf_trim(sb); 253 254return sb->len; 255} 256 257if(errno == ENOENT) 258return-1; 259 260die_errno(_("could not read '%s'"),am_path(state, file)); 261} 262 263/** 264 * Take a series of KEY='VALUE' lines where VALUE part is 265 * sq-quoted, and append <KEY, VALUE> at the end of the string list 266 */ 267static intparse_key_value_squoted(char*buf,struct string_list *list) 268{ 269while(*buf) { 270struct string_list_item *item; 271char*np; 272char*cp =strchr(buf,'='); 273if(!cp) 274return-1; 275 np =strchrnul(cp,'\n'); 276*cp++ ='\0'; 277 item =string_list_append(list, buf); 278 279 buf = np + (*np =='\n'); 280*np ='\0'; 281 cp =sq_dequote(cp); 282if(!cp) 283return-1; 284 item->util =xstrdup(cp); 285} 286return0; 287} 288 289/** 290 * Reads and parses the state directory's "author-script" file, and sets 291 * state->author_name, state->author_email and state->author_date accordingly. 292 * Returns 0 on success, -1 if the file could not be parsed. 293 * 294 * The author script is of the format: 295 * 296 * GIT_AUTHOR_NAME='$author_name' 297 * GIT_AUTHOR_EMAIL='$author_email' 298 * GIT_AUTHOR_DATE='$author_date' 299 * 300 * where $author_name, $author_email and $author_date are quoted. We are strict 301 * with our parsing, as the file was meant to be eval'd in the old git-am.sh 302 * script, and thus if the file differs from what this function expects, it is 303 * better to bail out than to do something that the user does not expect. 304 */ 305static intread_author_script(struct am_state *state) 306{ 307const char*filename =am_path(state,"author-script"); 308struct strbuf buf = STRBUF_INIT; 309struct string_list kv = STRING_LIST_INIT_DUP; 310int retval = -1;/* assume failure */ 311int fd; 312 313assert(!state->author_name); 314assert(!state->author_email); 315assert(!state->author_date); 316 317 fd =open(filename, O_RDONLY); 318if(fd <0) { 319if(errno == ENOENT) 320return0; 321die_errno(_("could not open '%s' for reading"), filename); 322} 323strbuf_read(&buf, fd,0); 324close(fd); 325if(parse_key_value_squoted(buf.buf, &kv)) 326goto finish; 327 328if(kv.nr !=3|| 329strcmp(kv.items[0].string,"GIT_AUTHOR_NAME") || 330strcmp(kv.items[1].string,"GIT_AUTHOR_EMAIL") || 331strcmp(kv.items[2].string,"GIT_AUTHOR_DATE")) 332goto finish; 333 state->author_name = kv.items[0].util; 334 state->author_email = kv.items[1].util; 335 state->author_date = kv.items[2].util; 336 retval =0; 337finish: 338string_list_clear(&kv, !!retval); 339strbuf_release(&buf); 340return retval; 341} 342 343/** 344 * Saves state->author_name, state->author_email and state->author_date in the 345 * state directory's "author-script" file. 346 */ 347static voidwrite_author_script(const struct am_state *state) 348{ 349struct strbuf sb = STRBUF_INIT; 350 351strbuf_addstr(&sb,"GIT_AUTHOR_NAME="); 352sq_quote_buf(&sb, state->author_name); 353strbuf_addch(&sb,'\n'); 354 355strbuf_addstr(&sb,"GIT_AUTHOR_EMAIL="); 356sq_quote_buf(&sb, state->author_email); 357strbuf_addch(&sb,'\n'); 358 359strbuf_addstr(&sb,"GIT_AUTHOR_DATE="); 360sq_quote_buf(&sb, state->author_date); 361strbuf_addch(&sb,'\n'); 362 363write_state_text(state,"author-script", sb.buf); 364 365strbuf_release(&sb); 366} 367 368/** 369 * Reads the commit message from the state directory's "final-commit" file, 370 * setting state->msg to its contents and state->msg_len to the length of its 371 * contents in bytes. 372 * 373 * Returns 0 on success, -1 if the file does not exist. 374 */ 375static intread_commit_msg(struct am_state *state) 376{ 377struct strbuf sb = STRBUF_INIT; 378 379assert(!state->msg); 380 381if(read_state_file(&sb, state,"final-commit",0) <0) { 382strbuf_release(&sb); 383return-1; 384} 385 386 state->msg =strbuf_detach(&sb, &state->msg_len); 387return0; 388} 389 390/** 391 * Saves state->msg in the state directory's "final-commit" file. 392 */ 393static voidwrite_commit_msg(const struct am_state *state) 394{ 395const char*filename =am_path(state,"final-commit"); 396write_file_buf(filename, state->msg, state->msg_len); 397} 398 399/** 400 * Loads state from disk. 401 */ 402static voidam_load(struct am_state *state) 403{ 404struct strbuf sb = STRBUF_INIT; 405 406if(read_state_file(&sb, state,"next",1) <0) 407BUG("state file 'next' does not exist"); 408 state->cur =strtol(sb.buf, NULL,10); 409 410if(read_state_file(&sb, state,"last",1) <0) 411BUG("state file 'last' does not exist"); 412 state->last =strtol(sb.buf, NULL,10); 413 414if(read_author_script(state) <0) 415die(_("could not parse author script")); 416 417read_commit_msg(state); 418 419if(read_state_file(&sb, state,"original-commit",1) <0) 420oidclr(&state->orig_commit); 421else if(get_oid_hex(sb.buf, &state->orig_commit) <0) 422die(_("could not parse%s"),am_path(state,"original-commit")); 423 424read_state_file(&sb, state,"threeway",1); 425 state->threeway = !strcmp(sb.buf,"t"); 426 427read_state_file(&sb, state,"quiet",1); 428 state->quiet = !strcmp(sb.buf,"t"); 429 430read_state_file(&sb, state,"sign",1); 431 state->signoff = !strcmp(sb.buf,"t"); 432 433read_state_file(&sb, state,"utf8",1); 434 state->utf8 = !strcmp(sb.buf,"t"); 435 436if(file_exists(am_path(state,"rerere-autoupdate"))) { 437read_state_file(&sb, state,"rerere-autoupdate",1); 438 state->allow_rerere_autoupdate =strcmp(sb.buf,"t") ? 439 RERERE_NOAUTOUPDATE : RERERE_AUTOUPDATE; 440}else{ 441 state->allow_rerere_autoupdate =0; 442} 443 444read_state_file(&sb, state,"keep",1); 445if(!strcmp(sb.buf,"t")) 446 state->keep = KEEP_TRUE; 447else if(!strcmp(sb.buf,"b")) 448 state->keep = KEEP_NON_PATCH; 449else 450 state->keep = KEEP_FALSE; 451 452read_state_file(&sb, state,"messageid",1); 453 state->message_id = !strcmp(sb.buf,"t"); 454 455read_state_file(&sb, state,"scissors",1); 456if(!strcmp(sb.buf,"t")) 457 state->scissors = SCISSORS_TRUE; 458else if(!strcmp(sb.buf,"f")) 459 state->scissors = SCISSORS_FALSE; 460else 461 state->scissors = SCISSORS_UNSET; 462 463read_state_file(&sb, state,"apply-opt",1); 464argv_array_clear(&state->git_apply_opts); 465if(sq_dequote_to_argv_array(sb.buf, &state->git_apply_opts) <0) 466die(_("could not parse%s"),am_path(state,"apply-opt")); 467 468 state->rebasing = !!file_exists(am_path(state,"rebasing")); 469 470strbuf_release(&sb); 471} 472 473/** 474 * Removes the am_state directory, forcefully terminating the current am 475 * session. 476 */ 477static voidam_destroy(const struct am_state *state) 478{ 479struct strbuf sb = STRBUF_INIT; 480 481strbuf_addstr(&sb, state->dir); 482remove_dir_recursively(&sb,0); 483strbuf_release(&sb); 484} 485 486/** 487 * Runs applypatch-msg hook. Returns its exit code. 488 */ 489static intrun_applypatch_msg_hook(struct am_state *state) 490{ 491int ret; 492 493assert(state->msg); 494 ret =run_hook_le(NULL,"applypatch-msg",am_path(state,"final-commit"), NULL); 495 496if(!ret) { 497FREE_AND_NULL(state->msg); 498if(read_commit_msg(state) <0) 499die(_("'%s' was deleted by the applypatch-msg hook"), 500am_path(state,"final-commit")); 501} 502 503return ret; 504} 505 506/** 507 * Runs post-rewrite hook. Returns it exit code. 508 */ 509static intrun_post_rewrite_hook(const struct am_state *state) 510{ 511struct child_process cp = CHILD_PROCESS_INIT; 512const char*hook =find_hook("post-rewrite"); 513int ret; 514 515if(!hook) 516return0; 517 518argv_array_push(&cp.args, hook); 519argv_array_push(&cp.args,"rebase"); 520 521 cp.in =xopen(am_path(state,"rewritten"), O_RDONLY); 522 cp.stdout_to_stderr =1; 523 524 ret =run_command(&cp); 525 526close(cp.in); 527return ret; 528} 529 530/** 531 * Reads the state directory's "rewritten" file, and copies notes from the old 532 * commits listed in the file to their rewritten commits. 533 * 534 * Returns 0 on success, -1 on failure. 535 */ 536static intcopy_notes_for_rebase(const struct am_state *state) 537{ 538struct notes_rewrite_cfg *c; 539struct strbuf sb = STRBUF_INIT; 540const char*invalid_line =_("Malformed input line: '%s'."); 541const char*msg ="Notes added by 'git rebase'"; 542FILE*fp; 543int ret =0; 544 545assert(state->rebasing); 546 547 c =init_copy_notes_for_rewrite("rebase"); 548if(!c) 549return0; 550 551 fp =xfopen(am_path(state,"rewritten"),"r"); 552 553while(!strbuf_getline_lf(&sb, fp)) { 554struct object_id from_obj, to_obj; 555 556if(sb.len != GIT_SHA1_HEXSZ *2+1) { 557 ret =error(invalid_line, sb.buf); 558goto finish; 559} 560 561if(get_oid_hex(sb.buf, &from_obj)) { 562 ret =error(invalid_line, sb.buf); 563goto finish; 564} 565 566if(sb.buf[GIT_SHA1_HEXSZ] !=' ') { 567 ret =error(invalid_line, sb.buf); 568goto finish; 569} 570 571if(get_oid_hex(sb.buf + GIT_SHA1_HEXSZ +1, &to_obj)) { 572 ret =error(invalid_line, sb.buf); 573goto finish; 574} 575 576if(copy_note_for_rewrite(c, &from_obj, &to_obj)) 577 ret =error(_("Failed to copy notes from '%s' to '%s'"), 578oid_to_hex(&from_obj),oid_to_hex(&to_obj)); 579} 580 581finish: 582finish_copy_notes_for_rewrite(c, msg); 583fclose(fp); 584strbuf_release(&sb); 585return ret; 586} 587 588/** 589 * Determines if the file looks like a piece of RFC2822 mail by grabbing all 590 * non-indented lines and checking if they look like they begin with valid 591 * header field names. 592 * 593 * Returns 1 if the file looks like a piece of mail, 0 otherwise. 594 */ 595static intis_mail(FILE*fp) 596{ 597const char*header_regex ="^[!-9;-~]+:"; 598struct strbuf sb = STRBUF_INIT; 599 regex_t regex; 600int ret =1; 601 602if(fseek(fp,0L, SEEK_SET)) 603die_errno(_("fseek failed")); 604 605if(regcomp(®ex, header_regex, REG_NOSUB | REG_EXTENDED)) 606die("invalid pattern:%s", header_regex); 607 608while(!strbuf_getline(&sb, fp)) { 609if(!sb.len) 610break;/* End of header */ 611 612/* Ignore indented folded lines */ 613if(*sb.buf =='\t'|| *sb.buf ==' ') 614continue; 615 616/* It's a header if it matches header_regex */ 617if(regexec(®ex, sb.buf,0, NULL,0)) { 618 ret =0; 619goto done; 620} 621} 622 623done: 624regfree(®ex); 625strbuf_release(&sb); 626return ret; 627} 628 629/** 630 * Attempts to detect the patch_format of the patches contained in `paths`, 631 * returning the PATCH_FORMAT_* enum value. Returns PATCH_FORMAT_UNKNOWN if 632 * detection fails. 633 */ 634static intdetect_patch_format(const char**paths) 635{ 636enum patch_format ret = PATCH_FORMAT_UNKNOWN; 637struct strbuf l1 = STRBUF_INIT; 638struct strbuf l2 = STRBUF_INIT; 639struct strbuf l3 = STRBUF_INIT; 640FILE*fp; 641 642/* 643 * We default to mbox format if input is from stdin and for directories 644 */ 645if(!*paths || !strcmp(*paths,"-") ||is_directory(*paths)) 646return PATCH_FORMAT_MBOX; 647 648/* 649 * Otherwise, check the first few lines of the first patch, starting 650 * from the first non-blank line, to try to detect its format. 651 */ 652 653 fp =xfopen(*paths,"r"); 654 655while(!strbuf_getline(&l1, fp)) { 656if(l1.len) 657break; 658} 659 660if(starts_with(l1.buf,"From ") ||starts_with(l1.buf,"From: ")) { 661 ret = PATCH_FORMAT_MBOX; 662goto done; 663} 664 665if(starts_with(l1.buf,"# This series applies on GIT commit")) { 666 ret = PATCH_FORMAT_STGIT_SERIES; 667goto done; 668} 669 670if(!strcmp(l1.buf,"# HG changeset patch")) { 671 ret = PATCH_FORMAT_HG; 672goto done; 673} 674 675strbuf_getline(&l2, fp); 676strbuf_getline(&l3, fp); 677 678/* 679 * If the second line is empty and the third is a From, Author or Date 680 * entry, this is likely an StGit patch. 681 */ 682if(l1.len && !l2.len && 683(starts_with(l3.buf,"From:") || 684starts_with(l3.buf,"Author:") || 685starts_with(l3.buf,"Date:"))) { 686 ret = PATCH_FORMAT_STGIT; 687goto done; 688} 689 690if(l1.len &&is_mail(fp)) { 691 ret = PATCH_FORMAT_MBOX; 692goto done; 693} 694 695done: 696fclose(fp); 697strbuf_release(&l1); 698strbuf_release(&l2); 699strbuf_release(&l3); 700return ret; 701} 702 703/** 704 * Splits out individual email patches from `paths`, where each path is either 705 * a mbox file or a Maildir. Returns 0 on success, -1 on failure. 706 */ 707static intsplit_mail_mbox(struct am_state *state,const char**paths, 708int keep_cr,int mboxrd) 709{ 710struct child_process cp = CHILD_PROCESS_INIT; 711struct strbuf last = STRBUF_INIT; 712int ret; 713 714 cp.git_cmd =1; 715argv_array_push(&cp.args,"mailsplit"); 716argv_array_pushf(&cp.args,"-d%d", state->prec); 717argv_array_pushf(&cp.args,"-o%s", state->dir); 718argv_array_push(&cp.args,"-b"); 719if(keep_cr) 720argv_array_push(&cp.args,"--keep-cr"); 721if(mboxrd) 722argv_array_push(&cp.args,"--mboxrd"); 723argv_array_push(&cp.args,"--"); 724argv_array_pushv(&cp.args, paths); 725 726 ret =capture_command(&cp, &last,8); 727if(ret) 728goto exit; 729 730 state->cur =1; 731 state->last =strtol(last.buf, NULL,10); 732 733exit: 734strbuf_release(&last); 735return ret ? -1:0; 736} 737 738/** 739 * Callback signature for split_mail_conv(). The foreign patch should be 740 * read from `in`, and the converted patch (in RFC2822 mail format) should be 741 * written to `out`. Return 0 on success, or -1 on failure. 742 */ 743typedefint(*mail_conv_fn)(FILE*out,FILE*in,int keep_cr); 744 745/** 746 * Calls `fn` for each file in `paths` to convert the foreign patch to the 747 * RFC2822 mail format suitable for parsing with git-mailinfo. 748 * 749 * Returns 0 on success, -1 on failure. 750 */ 751static intsplit_mail_conv(mail_conv_fn fn,struct am_state *state, 752const char**paths,int keep_cr) 753{ 754static const char*stdin_only[] = {"-", NULL}; 755int i; 756 757if(!*paths) 758 paths = stdin_only; 759 760for(i =0; *paths; paths++, i++) { 761FILE*in, *out; 762const char*mail; 763int ret; 764 765if(!strcmp(*paths,"-")) 766 in = stdin; 767else 768 in =fopen(*paths,"r"); 769 770if(!in) 771returnerror_errno(_("could not open '%s' for reading"), 772*paths); 773 774 mail =mkpath("%s/%0*d", state->dir, state->prec, i +1); 775 776 out =fopen(mail,"w"); 777if(!out) { 778if(in != stdin) 779fclose(in); 780returnerror_errno(_("could not open '%s' for writing"), 781 mail); 782} 783 784 ret =fn(out, in, keep_cr); 785 786fclose(out); 787if(in != stdin) 788fclose(in); 789 790if(ret) 791returnerror(_("could not parse patch '%s'"), *paths); 792} 793 794 state->cur =1; 795 state->last = i; 796return0; 797} 798 799/** 800 * A split_mail_conv() callback that converts an StGit patch to an RFC2822 801 * message suitable for parsing with git-mailinfo. 802 */ 803static intstgit_patch_to_mail(FILE*out,FILE*in,int keep_cr) 804{ 805struct strbuf sb = STRBUF_INIT; 806int subject_printed =0; 807 808while(!strbuf_getline_lf(&sb, in)) { 809const char*str; 810 811if(str_isspace(sb.buf)) 812continue; 813else if(skip_prefix(sb.buf,"Author:", &str)) 814fprintf(out,"From:%s\n", str); 815else if(starts_with(sb.buf,"From") ||starts_with(sb.buf,"Date")) 816fprintf(out,"%s\n", sb.buf); 817else if(!subject_printed) { 818fprintf(out,"Subject:%s\n", sb.buf); 819 subject_printed =1; 820}else{ 821fprintf(out,"\n%s\n", sb.buf); 822break; 823} 824} 825 826strbuf_reset(&sb); 827while(strbuf_fread(&sb,8192, in) >0) { 828fwrite(sb.buf,1, sb.len, out); 829strbuf_reset(&sb); 830} 831 832strbuf_release(&sb); 833return0; 834} 835 836/** 837 * This function only supports a single StGit series file in `paths`. 838 * 839 * Given an StGit series file, converts the StGit patches in the series into 840 * RFC2822 messages suitable for parsing with git-mailinfo, and queues them in 841 * the state directory. 842 * 843 * Returns 0 on success, -1 on failure. 844 */ 845static intsplit_mail_stgit_series(struct am_state *state,const char**paths, 846int keep_cr) 847{ 848const char*series_dir; 849char*series_dir_buf; 850FILE*fp; 851struct argv_array patches = ARGV_ARRAY_INIT; 852struct strbuf sb = STRBUF_INIT; 853int ret; 854 855if(!paths[0] || paths[1]) 856returnerror(_("Only one StGIT patch series can be applied at once")); 857 858 series_dir_buf =xstrdup(*paths); 859 series_dir =dirname(series_dir_buf); 860 861 fp =fopen(*paths,"r"); 862if(!fp) 863returnerror_errno(_("could not open '%s' for reading"), *paths); 864 865while(!strbuf_getline_lf(&sb, fp)) { 866if(*sb.buf =='#') 867continue;/* skip comment lines */ 868 869argv_array_push(&patches,mkpath("%s/%s", series_dir, sb.buf)); 870} 871 872fclose(fp); 873strbuf_release(&sb); 874free(series_dir_buf); 875 876 ret =split_mail_conv(stgit_patch_to_mail, state, patches.argv, keep_cr); 877 878argv_array_clear(&patches); 879return ret; 880} 881 882/** 883 * A split_patches_conv() callback that converts a mercurial patch to a RFC2822 884 * message suitable for parsing with git-mailinfo. 885 */ 886static inthg_patch_to_mail(FILE*out,FILE*in,int keep_cr) 887{ 888struct strbuf sb = STRBUF_INIT; 889int rc =0; 890 891while(!strbuf_getline_lf(&sb, in)) { 892const char*str; 893 894if(skip_prefix(sb.buf,"# User ", &str)) 895fprintf(out,"From:%s\n", str); 896else if(skip_prefix(sb.buf,"# Date ", &str)) { 897 timestamp_t timestamp; 898long tz, tz2; 899char*end; 900 901 errno =0; 902 timestamp =parse_timestamp(str, &end,10); 903if(errno) { 904 rc =error(_("invalid timestamp")); 905goto exit; 906} 907 908if(!skip_prefix(end," ", &str)) { 909 rc =error(_("invalid Date line")); 910goto exit; 911} 912 913 errno =0; 914 tz =strtol(str, &end,10); 915if(errno) { 916 rc =error(_("invalid timezone offset")); 917goto exit; 918} 919 920if(*end) { 921 rc =error(_("invalid Date line")); 922goto exit; 923} 924 925/* 926 * mercurial's timezone is in seconds west of UTC, 927 * however git's timezone is in hours + minutes east of 928 * UTC. Convert it. 929 */ 930 tz2 =labs(tz) /3600*100+labs(tz) %3600/60; 931if(tz >0) 932 tz2 = -tz2; 933 934fprintf(out,"Date:%s\n",show_date(timestamp, tz2,DATE_MODE(RFC2822))); 935}else if(starts_with(sb.buf,"# ")) { 936continue; 937}else{ 938fprintf(out,"\n%s\n", sb.buf); 939break; 940} 941} 942 943strbuf_reset(&sb); 944while(strbuf_fread(&sb,8192, in) >0) { 945fwrite(sb.buf,1, sb.len, out); 946strbuf_reset(&sb); 947} 948exit: 949strbuf_release(&sb); 950return rc; 951} 952 953/** 954 * Splits a list of files/directories into individual email patches. Each path 955 * in `paths` must be a file/directory that is formatted according to 956 * `patch_format`. 957 * 958 * Once split out, the individual email patches will be stored in the state 959 * directory, with each patch's filename being its index, padded to state->prec 960 * digits. 961 * 962 * state->cur will be set to the index of the first mail, and state->last will 963 * be set to the index of the last mail. 964 * 965 * Set keep_cr to 0 to convert all lines ending with \r\n to end with \n, 1 966 * to disable this behavior, -1 to use the default configured setting. 967 * 968 * Returns 0 on success, -1 on failure. 969 */ 970static intsplit_mail(struct am_state *state,enum patch_format patch_format, 971const char**paths,int keep_cr) 972{ 973if(keep_cr <0) { 974 keep_cr =0; 975git_config_get_bool("am.keepcr", &keep_cr); 976} 977 978switch(patch_format) { 979case PATCH_FORMAT_MBOX: 980returnsplit_mail_mbox(state, paths, keep_cr,0); 981case PATCH_FORMAT_STGIT: 982returnsplit_mail_conv(stgit_patch_to_mail, state, paths, keep_cr); 983case PATCH_FORMAT_STGIT_SERIES: 984returnsplit_mail_stgit_series(state, paths, keep_cr); 985case PATCH_FORMAT_HG: 986returnsplit_mail_conv(hg_patch_to_mail, state, paths, keep_cr); 987case PATCH_FORMAT_MBOXRD: 988returnsplit_mail_mbox(state, paths, keep_cr,1); 989default: 990BUG("invalid patch_format"); 991} 992return-1; 993} 994 995/** 996 * Setup a new am session for applying patches 997 */ 998static voidam_setup(struct am_state *state,enum patch_format patch_format, 999const char**paths,int keep_cr)1000{1001struct object_id curr_head;1002const char*str;1003struct strbuf sb = STRBUF_INIT;10041005if(!patch_format)1006 patch_format =detect_patch_format(paths);10071008if(!patch_format) {1009fprintf_ln(stderr,_("Patch format detection failed."));1010exit(128);1011}10121013if(mkdir(state->dir,0777) <0&& errno != EEXIST)1014die_errno(_("failed to create directory '%s'"), state->dir);1015delete_ref(NULL,"REBASE_HEAD", NULL, REF_NO_DEREF);10161017if(split_mail(state, patch_format, paths, keep_cr) <0) {1018am_destroy(state);1019die(_("Failed to split patches."));1020}10211022if(state->rebasing)1023 state->threeway =1;10241025write_state_bool(state,"threeway", state->threeway);1026write_state_bool(state,"quiet", state->quiet);1027write_state_bool(state,"sign", state->signoff);1028write_state_bool(state,"utf8", state->utf8);10291030if(state->allow_rerere_autoupdate)1031write_state_bool(state,"rerere-autoupdate",1032 state->allow_rerere_autoupdate == RERERE_AUTOUPDATE);10331034switch(state->keep) {1035case KEEP_FALSE:1036 str ="f";1037break;1038case KEEP_TRUE:1039 str ="t";1040break;1041case KEEP_NON_PATCH:1042 str ="b";1043break;1044default:1045BUG("invalid value for state->keep");1046}10471048write_state_text(state,"keep", str);1049write_state_bool(state,"messageid", state->message_id);10501051switch(state->scissors) {1052case SCISSORS_UNSET:1053 str ="";1054break;1055case SCISSORS_FALSE:1056 str ="f";1057break;1058case SCISSORS_TRUE:1059 str ="t";1060break;1061default:1062BUG("invalid value for state->scissors");1063}1064write_state_text(state,"scissors", str);10651066sq_quote_argv(&sb, state->git_apply_opts.argv);1067write_state_text(state,"apply-opt", sb.buf);10681069if(state->rebasing)1070write_state_text(state,"rebasing","");1071else1072write_state_text(state,"applying","");10731074if(!get_oid("HEAD", &curr_head)) {1075write_state_text(state,"abort-safety",oid_to_hex(&curr_head));1076if(!state->rebasing)1077update_ref("am","ORIG_HEAD", &curr_head, NULL,0,1078 UPDATE_REFS_DIE_ON_ERR);1079}else{1080write_state_text(state,"abort-safety","");1081if(!state->rebasing)1082delete_ref(NULL,"ORIG_HEAD", NULL,0);1083}10841085/*1086 * NOTE: Since the "next" and "last" files determine if an am_state1087 * session is in progress, they should be written last.1088 */10891090write_state_count(state,"next", state->cur);1091write_state_count(state,"last", state->last);10921093strbuf_release(&sb);1094}10951096/**1097 * Increments the patch pointer, and cleans am_state for the application of the1098 * next patch.1099 */1100static voidam_next(struct am_state *state)1101{1102struct object_id head;11031104FREE_AND_NULL(state->author_name);1105FREE_AND_NULL(state->author_email);1106FREE_AND_NULL(state->author_date);1107FREE_AND_NULL(state->msg);1108 state->msg_len =0;11091110unlink(am_path(state,"author-script"));1111unlink(am_path(state,"final-commit"));11121113oidclr(&state->orig_commit);1114unlink(am_path(state,"original-commit"));1115delete_ref(NULL,"REBASE_HEAD", NULL, REF_NO_DEREF);11161117if(!get_oid("HEAD", &head))1118write_state_text(state,"abort-safety",oid_to_hex(&head));1119else1120write_state_text(state,"abort-safety","");11211122 state->cur++;1123write_state_count(state,"next", state->cur);1124}11251126/**1127 * Returns the filename of the current patch email.1128 */1129static const char*msgnum(const struct am_state *state)1130{1131static struct strbuf sb = STRBUF_INIT;11321133strbuf_reset(&sb);1134strbuf_addf(&sb,"%0*d", state->prec, state->cur);11351136return sb.buf;1137}11381139/**1140 * Refresh and write index.1141 */1142static voidrefresh_and_write_cache(void)1143{1144struct lock_file lock_file = LOCK_INIT;11451146hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);1147refresh_cache(REFRESH_QUIET);1148if(write_locked_index(&the_index, &lock_file, COMMIT_LOCK))1149die(_("unable to write index file"));1150}11511152/**1153 * Dies with a user-friendly message on how to proceed after resolving the1154 * problem. This message can be overridden with state->resolvemsg.1155 */1156static void NORETURN die_user_resolve(const struct am_state *state)1157{1158if(state->resolvemsg) {1159printf_ln("%s", state->resolvemsg);1160}else{1161const char*cmdline = state->interactive ?"git am -i":"git am";11621163printf_ln(_("When you have resolved this problem, run\"%s--continue\"."), cmdline);1164printf_ln(_("If you prefer to skip this patch, run\"%s--skip\"instead."), cmdline);1165printf_ln(_("To restore the original branch and stop patching, run\"%s--abort\"."), cmdline);1166}11671168exit(128);1169}11701171/**1172 * Appends signoff to the "msg" field of the am_state.1173 */1174static voidam_append_signoff(struct am_state *state)1175{1176struct strbuf sb = STRBUF_INIT;11771178strbuf_attach(&sb, state->msg, state->msg_len, state->msg_len);1179append_signoff(&sb,0,0);1180 state->msg =strbuf_detach(&sb, &state->msg_len);1181}11821183/**1184 * Parses `mail` using git-mailinfo, extracting its patch and authorship info.1185 * state->msg will be set to the patch message. state->author_name,1186 * state->author_email and state->author_date will be set to the patch author's1187 * name, email and date respectively. The patch body will be written to the1188 * state directory's "patch" file.1189 *1190 * Returns 1 if the patch should be skipped, 0 otherwise.1191 */1192static intparse_mail(struct am_state *state,const char*mail)1193{1194FILE*fp;1195struct strbuf sb = STRBUF_INIT;1196struct strbuf msg = STRBUF_INIT;1197struct strbuf author_name = STRBUF_INIT;1198struct strbuf author_date = STRBUF_INIT;1199struct strbuf author_email = STRBUF_INIT;1200int ret =0;1201struct mailinfo mi;12021203setup_mailinfo(&mi);12041205if(state->utf8)1206 mi.metainfo_charset =get_commit_output_encoding();1207else1208 mi.metainfo_charset = NULL;12091210switch(state->keep) {1211case KEEP_FALSE:1212break;1213case KEEP_TRUE:1214 mi.keep_subject =1;1215break;1216case KEEP_NON_PATCH:1217 mi.keep_non_patch_brackets_in_subject =1;1218break;1219default:1220BUG("invalid value for state->keep");1221}12221223if(state->message_id)1224 mi.add_message_id =1;12251226switch(state->scissors) {1227case SCISSORS_UNSET:1228break;1229case SCISSORS_FALSE:1230 mi.use_scissors =0;1231break;1232case SCISSORS_TRUE:1233 mi.use_scissors =1;1234break;1235default:1236BUG("invalid value for state->scissors");1237}12381239 mi.input =xfopen(mail,"r");1240 mi.output =xfopen(am_path(state,"info"),"w");1241if(mailinfo(&mi,am_path(state,"msg"),am_path(state,"patch")))1242die("could not parse patch");12431244fclose(mi.input);1245fclose(mi.output);12461247/* Extract message and author information */1248 fp =xfopen(am_path(state,"info"),"r");1249while(!strbuf_getline_lf(&sb, fp)) {1250const char*x;12511252if(skip_prefix(sb.buf,"Subject: ", &x)) {1253if(msg.len)1254strbuf_addch(&msg,'\n');1255strbuf_addstr(&msg, x);1256}else if(skip_prefix(sb.buf,"Author: ", &x))1257strbuf_addstr(&author_name, x);1258else if(skip_prefix(sb.buf,"Email: ", &x))1259strbuf_addstr(&author_email, x);1260else if(skip_prefix(sb.buf,"Date: ", &x))1261strbuf_addstr(&author_date, x);1262}1263fclose(fp);12641265/* Skip pine's internal folder data */1266if(!strcmp(author_name.buf,"Mail System Internal Data")) {1267 ret =1;1268goto finish;1269}12701271if(is_empty_file(am_path(state,"patch"))) {1272printf_ln(_("Patch is empty."));1273die_user_resolve(state);1274}12751276strbuf_addstr(&msg,"\n\n");1277strbuf_addbuf(&msg, &mi.log_message);1278strbuf_stripspace(&msg,0);12791280assert(!state->author_name);1281 state->author_name =strbuf_detach(&author_name, NULL);12821283assert(!state->author_email);1284 state->author_email =strbuf_detach(&author_email, NULL);12851286assert(!state->author_date);1287 state->author_date =strbuf_detach(&author_date, NULL);12881289assert(!state->msg);1290 state->msg =strbuf_detach(&msg, &state->msg_len);12911292finish:1293strbuf_release(&msg);1294strbuf_release(&author_date);1295strbuf_release(&author_email);1296strbuf_release(&author_name);1297strbuf_release(&sb);1298clear_mailinfo(&mi);1299return ret;1300}13011302/**1303 * Sets commit_id to the commit hash where the mail was generated from.1304 * Returns 0 on success, -1 on failure.1305 */1306static intget_mail_commit_oid(struct object_id *commit_id,const char*mail)1307{1308struct strbuf sb = STRBUF_INIT;1309FILE*fp =xfopen(mail,"r");1310const char*x;1311int ret =0;13121313if(strbuf_getline_lf(&sb, fp) ||1314!skip_prefix(sb.buf,"From ", &x) ||1315get_oid_hex(x, commit_id) <0)1316 ret = -1;13171318strbuf_release(&sb);1319fclose(fp);1320return ret;1321}13221323/**1324 * Sets state->msg, state->author_name, state->author_email, state->author_date1325 * to the commit's respective info.1326 */1327static voidget_commit_info(struct am_state *state,struct commit *commit)1328{1329const char*buffer, *ident_line, *msg;1330size_t ident_len;1331struct ident_split id;13321333 buffer =logmsg_reencode(commit, NULL,get_commit_output_encoding());13341335 ident_line =find_commit_header(buffer,"author", &ident_len);13361337if(split_ident_line(&id, ident_line, ident_len) <0)1338die(_("invalid ident line: %.*s"), (int)ident_len, ident_line);13391340assert(!state->author_name);1341if(id.name_begin)1342 state->author_name =1343xmemdupz(id.name_begin, id.name_end - id.name_begin);1344else1345 state->author_name =xstrdup("");13461347assert(!state->author_email);1348if(id.mail_begin)1349 state->author_email =1350xmemdupz(id.mail_begin, id.mail_end - id.mail_begin);1351else1352 state->author_email =xstrdup("");13531354assert(!state->author_date);1355 state->author_date =xstrdup(show_ident_date(&id,DATE_MODE(NORMAL)));13561357assert(!state->msg);1358 msg =strstr(buffer,"\n\n");1359if(!msg)1360die(_("unable to parse commit%s"),oid_to_hex(&commit->object.oid));1361 state->msg =xstrdup(msg +2);1362 state->msg_len =strlen(state->msg);1363unuse_commit_buffer(commit, buffer);1364}13651366/**1367 * Writes `commit` as a patch to the state directory's "patch" file.1368 */1369static voidwrite_commit_patch(const struct am_state *state,struct commit *commit)1370{1371struct rev_info rev_info;1372FILE*fp;13731374 fp =xfopen(am_path(state,"patch"),"w");1375init_revisions(&rev_info, NULL);1376 rev_info.diff =1;1377 rev_info.abbrev =0;1378 rev_info.disable_stdin =1;1379 rev_info.show_root_diff =1;1380 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;1381 rev_info.no_commit_id =1;1382 rev_info.diffopt.flags.binary =1;1383 rev_info.diffopt.flags.full_index =1;1384 rev_info.diffopt.use_color =0;1385 rev_info.diffopt.file = fp;1386 rev_info.diffopt.close_file =1;1387add_pending_object(&rev_info, &commit->object,"");1388diff_setup_done(&rev_info.diffopt);1389log_tree_commit(&rev_info, commit);1390}13911392/**1393 * Writes the diff of the index against HEAD as a patch to the state1394 * directory's "patch" file.1395 */1396static voidwrite_index_patch(const struct am_state *state)1397{1398struct tree *tree;1399struct object_id head;1400struct rev_info rev_info;1401FILE*fp;14021403if(!get_oid_tree("HEAD", &head))1404 tree =lookup_tree(the_repository, &head);1405else1406 tree =lookup_tree(the_repository,1407 the_repository->hash_algo->empty_tree);14081409 fp =xfopen(am_path(state,"patch"),"w");1410init_revisions(&rev_info, NULL);1411 rev_info.diff =1;1412 rev_info.disable_stdin =1;1413 rev_info.no_commit_id =1;1414 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;1415 rev_info.diffopt.use_color =0;1416 rev_info.diffopt.file = fp;1417 rev_info.diffopt.close_file =1;1418add_pending_object(&rev_info, &tree->object,"");1419diff_setup_done(&rev_info.diffopt);1420run_diff_index(&rev_info,1);1421}14221423/**1424 * Like parse_mail(), but parses the mail by looking up its commit ID1425 * directly. This is used in --rebasing mode to bypass git-mailinfo's munging1426 * of patches.1427 *1428 * state->orig_commit will be set to the original commit ID.1429 *1430 * Will always return 0 as the patch should never be skipped.1431 */1432static intparse_mail_rebase(struct am_state *state,const char*mail)1433{1434struct commit *commit;1435struct object_id commit_oid;14361437if(get_mail_commit_oid(&commit_oid, mail) <0)1438die(_("could not parse%s"), mail);14391440 commit =lookup_commit_or_die(&commit_oid, mail);14411442get_commit_info(state, commit);14431444write_commit_patch(state, commit);14451446oidcpy(&state->orig_commit, &commit_oid);1447write_state_text(state,"original-commit",oid_to_hex(&commit_oid));1448update_ref("am","REBASE_HEAD", &commit_oid,1449 NULL, REF_NO_DEREF, UPDATE_REFS_DIE_ON_ERR);14501451return0;1452}14531454/**1455 * Applies current patch with git-apply. Returns 0 on success, -1 otherwise. If1456 * `index_file` is not NULL, the patch will be applied to that index.1457 */1458static intrun_apply(const struct am_state *state,const char*index_file)1459{1460struct argv_array apply_paths = ARGV_ARRAY_INIT;1461struct argv_array apply_opts = ARGV_ARRAY_INIT;1462struct apply_state apply_state;1463int res, opts_left;1464int force_apply =0;1465int options =0;14661467if(init_apply_state(&apply_state, the_repository, NULL))1468BUG("init_apply_state() failed");14691470argv_array_push(&apply_opts,"apply");1471argv_array_pushv(&apply_opts, state->git_apply_opts.argv);14721473 opts_left =apply_parse_options(apply_opts.argc, apply_opts.argv,1474&apply_state, &force_apply, &options,1475 NULL);14761477if(opts_left !=0)1478die("unknown option passed through to git apply");14791480if(index_file) {1481 apply_state.index_file = index_file;1482 apply_state.cached =1;1483}else1484 apply_state.check_index =1;14851486/*1487 * If we are allowed to fall back on 3-way merge, don't give false1488 * errors during the initial attempt.1489 */1490if(state->threeway && !index_file)1491 apply_state.apply_verbosity = verbosity_silent;14921493if(check_apply_state(&apply_state, force_apply))1494BUG("check_apply_state() failed");14951496argv_array_push(&apply_paths,am_path(state,"patch"));14971498 res =apply_all_patches(&apply_state, apply_paths.argc, apply_paths.argv, options);14991500argv_array_clear(&apply_paths);1501argv_array_clear(&apply_opts);1502clear_apply_state(&apply_state);15031504if(res)1505return res;15061507if(index_file) {1508/* Reload index as apply_all_patches() will have modified it. */1509discard_cache();1510read_cache_from(index_file);1511}15121513return0;1514}15151516/**1517 * Builds an index that contains just the blobs needed for a 3way merge.1518 */1519static intbuild_fake_ancestor(const struct am_state *state,const char*index_file)1520{1521struct child_process cp = CHILD_PROCESS_INIT;15221523 cp.git_cmd =1;1524argv_array_push(&cp.args,"apply");1525argv_array_pushv(&cp.args, state->git_apply_opts.argv);1526argv_array_pushf(&cp.args,"--build-fake-ancestor=%s", index_file);1527argv_array_push(&cp.args,am_path(state,"patch"));15281529if(run_command(&cp))1530return-1;15311532return0;1533}15341535/**1536 * Attempt a threeway merge, using index_path as the temporary index.1537 */1538static intfall_back_threeway(const struct am_state *state,const char*index_path)1539{1540struct object_id orig_tree, their_tree, our_tree;1541const struct object_id *bases[1] = { &orig_tree };1542struct merge_options o;1543struct commit *result;1544char*their_tree_name;15451546if(get_oid("HEAD", &our_tree) <0)1547oidcpy(&our_tree, the_hash_algo->empty_tree);15481549if(build_fake_ancestor(state, index_path))1550returnerror("could not build fake ancestor");15511552discard_cache();1553read_cache_from(index_path);15541555if(write_index_as_tree(&orig_tree, &the_index, index_path,0, NULL))1556returnerror(_("Repository lacks necessary blobs to fall back on 3-way merge."));15571558say(state, stdout,_("Using index info to reconstruct a base tree..."));15591560if(!state->quiet) {1561/*1562 * List paths that needed 3-way fallback, so that the user can1563 * review them with extra care to spot mismerges.1564 */1565struct rev_info rev_info;1566const char*diff_filter_str ="--diff-filter=AM";15671568init_revisions(&rev_info, NULL);1569 rev_info.diffopt.output_format = DIFF_FORMAT_NAME_STATUS;1570diff_opt_parse(&rev_info.diffopt, &diff_filter_str,1, rev_info.prefix);1571add_pending_oid(&rev_info,"HEAD", &our_tree,0);1572diff_setup_done(&rev_info.diffopt);1573run_diff_index(&rev_info,1);1574}15751576if(run_apply(state, index_path))1577returnerror(_("Did you hand edit your patch?\n"1578"It does not apply to blobs recorded in its index."));15791580if(write_index_as_tree(&their_tree, &the_index, index_path,0, NULL))1581returnerror("could not write tree");15821583say(state, stdout,_("Falling back to patching base and 3-way merge..."));15841585discard_cache();1586read_cache();15871588/*1589 * This is not so wrong. Depending on which base we picked, orig_tree1590 * may be wildly different from ours, but their_tree has the same set of1591 * wildly different changes in parts the patch did not touch, so1592 * recursive ends up canceling them, saying that we reverted all those1593 * changes.1594 */15951596init_merge_options(&o);15971598 o.branch1 ="HEAD";1599 their_tree_name =xstrfmt("%.*s",linelen(state->msg), state->msg);1600 o.branch2 = their_tree_name;16011602if(state->quiet)1603 o.verbosity =0;16041605if(merge_recursive_generic(&o, &our_tree, &their_tree,1, bases, &result)) {1606rerere(state->allow_rerere_autoupdate);1607free(their_tree_name);1608returnerror(_("Failed to merge in the changes."));1609}16101611free(their_tree_name);1612return0;1613}16141615/**1616 * Commits the current index with state->msg as the commit message and1617 * state->author_name, state->author_email and state->author_date as the author1618 * information.1619 */1620static voiddo_commit(const struct am_state *state)1621{1622struct object_id tree, parent, commit;1623const struct object_id *old_oid;1624struct commit_list *parents = NULL;1625const char*reflog_msg, *author;1626struct strbuf sb = STRBUF_INIT;16271628if(run_hook_le(NULL,"pre-applypatch", NULL))1629exit(1);16301631if(write_cache_as_tree(&tree,0, NULL))1632die(_("git write-tree failed to write a tree"));16331634if(!get_oid_commit("HEAD", &parent)) {1635 old_oid = &parent;1636commit_list_insert(lookup_commit(the_repository, &parent),1637&parents);1638}else{1639 old_oid = NULL;1640say(state, stderr,_("applying to an empty history"));1641}16421643 author =fmt_ident(state->author_name, state->author_email,1644 state->ignore_date ? NULL : state->author_date,1645 IDENT_STRICT);16461647if(state->committer_date_is_author_date)1648setenv("GIT_COMMITTER_DATE",1649 state->ignore_date ?"": state->author_date,1);16501651if(commit_tree(state->msg, state->msg_len, &tree, parents, &commit,1652 author, state->sign_commit))1653die(_("failed to write commit object"));16541655 reflog_msg =getenv("GIT_REFLOG_ACTION");1656if(!reflog_msg)1657 reflog_msg ="am";16581659strbuf_addf(&sb,"%s: %.*s", reflog_msg,linelen(state->msg),1660 state->msg);16611662update_ref(sb.buf,"HEAD", &commit, old_oid,0,1663 UPDATE_REFS_DIE_ON_ERR);16641665if(state->rebasing) {1666FILE*fp =xfopen(am_path(state,"rewritten"),"a");16671668assert(!is_null_oid(&state->orig_commit));1669fprintf(fp,"%s",oid_to_hex(&state->orig_commit));1670fprintf(fp,"%s\n",oid_to_hex(&commit));1671fclose(fp);1672}16731674run_hook_le(NULL,"post-applypatch", NULL);16751676strbuf_release(&sb);1677}16781679/**1680 * Validates the am_state for resuming -- the "msg" and authorship fields must1681 * be filled up.1682 */1683static voidvalidate_resume_state(const struct am_state *state)1684{1685if(!state->msg)1686die(_("cannot resume:%sdoes not exist."),1687am_path(state,"final-commit"));16881689if(!state->author_name || !state->author_email || !state->author_date)1690die(_("cannot resume:%sdoes not exist."),1691am_path(state,"author-script"));1692}16931694/**1695 * Interactively prompt the user on whether the current patch should be1696 * applied.1697 *1698 * Returns 0 if the user chooses to apply the patch, 1 if the user chooses to1699 * skip it.1700 */1701static intdo_interactive(struct am_state *state)1702{1703assert(state->msg);17041705if(!isatty(0))1706die(_("cannot be interactive without stdin connected to a terminal."));17071708for(;;) {1709const char*reply;17101711puts(_("Commit Body is:"));1712puts("--------------------------");1713printf("%s", state->msg);1714puts("--------------------------");17151716/*1717 * TRANSLATORS: Make sure to include [y], [n], [e], [v] and [a]1718 * in your translation. The program will only accept English1719 * input at this point.1720 */1721 reply =git_prompt(_("Apply? [y]es/[n]o/[e]dit/[v]iew patch/[a]ccept all: "), PROMPT_ECHO);17221723if(!reply) {1724continue;1725}else if(*reply =='y'|| *reply =='Y') {1726return0;1727}else if(*reply =='a'|| *reply =='A') {1728 state->interactive =0;1729return0;1730}else if(*reply =='n'|| *reply =='N') {1731return1;1732}else if(*reply =='e'|| *reply =='E') {1733struct strbuf msg = STRBUF_INIT;17341735if(!launch_editor(am_path(state,"final-commit"), &msg, NULL)) {1736free(state->msg);1737 state->msg =strbuf_detach(&msg, &state->msg_len);1738}1739strbuf_release(&msg);1740}else if(*reply =='v'|| *reply =='V') {1741const char*pager =git_pager(1);1742struct child_process cp = CHILD_PROCESS_INIT;17431744if(!pager)1745 pager ="cat";1746prepare_pager_args(&cp, pager);1747argv_array_push(&cp.args,am_path(state,"patch"));1748run_command(&cp);1749}1750}1751}17521753/**1754 * Applies all queued mail.1755 *1756 * If `resume` is true, we are "resuming". The "msg" and authorship fields, as1757 * well as the state directory's "patch" file is used as-is for applying the1758 * patch and committing it.1759 */1760static voidam_run(struct am_state *state,int resume)1761{1762const char*argv_gc_auto[] = {"gc","--auto", NULL};1763struct strbuf sb = STRBUF_INIT;17641765unlink(am_path(state,"dirtyindex"));17661767refresh_and_write_cache();17681769if(index_has_changes(&the_index, NULL, &sb)) {1770write_state_bool(state,"dirtyindex",1);1771die(_("Dirty index: cannot apply patches (dirty:%s)"), sb.buf);1772}17731774strbuf_release(&sb);17751776while(state->cur <= state->last) {1777const char*mail =am_path(state,msgnum(state));1778int apply_status;17791780reset_ident_date();17811782if(!file_exists(mail))1783goto next;17841785if(resume) {1786validate_resume_state(state);1787}else{1788int skip;17891790if(state->rebasing)1791 skip =parse_mail_rebase(state, mail);1792else1793 skip =parse_mail(state, mail);17941795if(skip)1796goto next;/* mail should be skipped */17971798if(state->signoff)1799am_append_signoff(state);18001801write_author_script(state);1802write_commit_msg(state);1803}18041805if(state->interactive &&do_interactive(state))1806goto next;18071808if(run_applypatch_msg_hook(state))1809exit(1);18101811say(state, stdout,_("Applying: %.*s"),linelen(state->msg), state->msg);18121813 apply_status =run_apply(state, NULL);18141815if(apply_status && state->threeway) {1816struct strbuf sb = STRBUF_INIT;18171818strbuf_addstr(&sb,am_path(state,"patch-merge-index"));1819 apply_status =fall_back_threeway(state, sb.buf);1820strbuf_release(&sb);18211822/*1823 * Applying the patch to an earlier tree and merging1824 * the result may have produced the same tree as ours.1825 */1826if(!apply_status &&1827!index_has_changes(&the_index, NULL, NULL)) {1828say(state, stdout,_("No changes -- Patch already applied."));1829goto next;1830}1831}18321833if(apply_status) {1834printf_ln(_("Patch failed at%s%.*s"),msgnum(state),1835linelen(state->msg), state->msg);18361837if(advice_amworkdir)1838advise(_("Use 'git am --show-current-patch' to see the failed patch"));18391840die_user_resolve(state);1841}18421843do_commit(state);18441845next:1846am_next(state);18471848if(resume)1849am_load(state);1850 resume =0;1851}18521853if(!is_empty_file(am_path(state,"rewritten"))) {1854assert(state->rebasing);1855copy_notes_for_rebase(state);1856run_post_rewrite_hook(state);1857}18581859/*1860 * In rebasing mode, it's up to the caller to take care of1861 * housekeeping.1862 */1863if(!state->rebasing) {1864am_destroy(state);1865close_all_packs(the_repository->objects);1866run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);1867}1868}18691870/**1871 * Resume the current am session after patch application failure. The user did1872 * all the hard work, and we do not have to do any patch application. Just1873 * trust and commit what the user has in the index and working tree.1874 */1875static voidam_resolve(struct am_state *state)1876{1877validate_resume_state(state);18781879say(state, stdout,_("Applying: %.*s"),linelen(state->msg), state->msg);18801881if(!index_has_changes(&the_index, NULL, NULL)) {1882printf_ln(_("No changes - did you forget to use 'git add'?\n"1883"If there is nothing left to stage, chances are that something else\n"1884"already introduced the same changes; you might want to skip this patch."));1885die_user_resolve(state);1886}18871888if(unmerged_cache()) {1889printf_ln(_("You still have unmerged paths in your index.\n"1890"You should 'git add' each file with resolved conflicts to mark them as such.\n"1891"You might run `git rm` on a file to accept\"deleted by them\"for it."));1892die_user_resolve(state);1893}18941895if(state->interactive) {1896write_index_patch(state);1897if(do_interactive(state))1898goto next;1899}19001901rerere(0);19021903do_commit(state);19041905next:1906am_next(state);1907am_load(state);1908am_run(state,0);1909}19101911/**1912 * Performs a checkout fast-forward from `head` to `remote`. If `reset` is1913 * true, any unmerged entries will be discarded. Returns 0 on success, -1 on1914 * failure.1915 */1916static intfast_forward_to(struct tree *head,struct tree *remote,int reset)1917{1918struct lock_file lock_file = LOCK_INIT;1919struct unpack_trees_options opts;1920struct tree_desc t[2];19211922if(parse_tree(head) ||parse_tree(remote))1923return-1;19241925hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);19261927refresh_cache(REFRESH_QUIET);19281929memset(&opts,0,sizeof(opts));1930 opts.head_idx =1;1931 opts.src_index = &the_index;1932 opts.dst_index = &the_index;1933 opts.update =1;1934 opts.merge =1;1935 opts.reset = reset;1936 opts.fn = twoway_merge;1937init_tree_desc(&t[0], head->buffer, head->size);1938init_tree_desc(&t[1], remote->buffer, remote->size);19391940if(unpack_trees(2, t, &opts)) {1941rollback_lock_file(&lock_file);1942return-1;1943}19441945if(write_locked_index(&the_index, &lock_file, COMMIT_LOCK))1946die(_("unable to write new index file"));19471948return0;1949}19501951/**1952 * Merges a tree into the index. The index's stat info will take precedence1953 * over the merged tree's. Returns 0 on success, -1 on failure.1954 */1955static intmerge_tree(struct tree *tree)1956{1957struct lock_file lock_file = LOCK_INIT;1958struct unpack_trees_options opts;1959struct tree_desc t[1];19601961if(parse_tree(tree))1962return-1;19631964hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);19651966memset(&opts,0,sizeof(opts));1967 opts.head_idx =1;1968 opts.src_index = &the_index;1969 opts.dst_index = &the_index;1970 opts.merge =1;1971 opts.fn = oneway_merge;1972init_tree_desc(&t[0], tree->buffer, tree->size);19731974if(unpack_trees(1, t, &opts)) {1975rollback_lock_file(&lock_file);1976return-1;1977}19781979if(write_locked_index(&the_index, &lock_file, COMMIT_LOCK))1980die(_("unable to write new index file"));19811982return0;1983}19841985/**1986 * Clean the index without touching entries that are not modified between1987 * `head` and `remote`.1988 */1989static intclean_index(const struct object_id *head,const struct object_id *remote)1990{1991struct tree *head_tree, *remote_tree, *index_tree;1992struct object_id index;19931994 head_tree =parse_tree_indirect(head);1995if(!head_tree)1996returnerror(_("Could not parse object '%s'."),oid_to_hex(head));19971998 remote_tree =parse_tree_indirect(remote);1999if(!remote_tree)2000returnerror(_("Could not parse object '%s'."),oid_to_hex(remote));20012002read_cache_unmerged();20032004if(fast_forward_to(head_tree, head_tree,1))2005return-1;20062007if(write_cache_as_tree(&index,0, NULL))2008return-1;20092010 index_tree =parse_tree_indirect(&index);2011if(!index_tree)2012returnerror(_("Could not parse object '%s'."),oid_to_hex(&index));20132014if(fast_forward_to(index_tree, remote_tree,0))2015return-1;20162017if(merge_tree(remote_tree))2018return-1;20192020remove_branch_state();20212022return0;2023}20242025/**2026 * Resets rerere's merge resolution metadata.2027 */2028static voidam_rerere_clear(void)2029{2030struct string_list merge_rr = STRING_LIST_INIT_DUP;2031rerere_clear(&merge_rr);2032string_list_clear(&merge_rr,1);2033}20342035/**2036 * Resume the current am session by skipping the current patch.2037 */2038static voidam_skip(struct am_state *state)2039{2040struct object_id head;20412042am_rerere_clear();20432044if(get_oid("HEAD", &head))2045oidcpy(&head, the_hash_algo->empty_tree);20462047if(clean_index(&head, &head))2048die(_("failed to clean index"));20492050am_next(state);2051am_load(state);2052am_run(state,0);2053}20542055/**2056 * Returns true if it is safe to reset HEAD to the ORIG_HEAD, false otherwise.2057 *2058 * It is not safe to reset HEAD when:2059 * 1. git-am previously failed because the index was dirty.2060 * 2. HEAD has moved since git-am previously failed.2061 */2062static intsafe_to_abort(const struct am_state *state)2063{2064struct strbuf sb = STRBUF_INIT;2065struct object_id abort_safety, head;20662067if(file_exists(am_path(state,"dirtyindex")))2068return0;20692070if(read_state_file(&sb, state,"abort-safety",1) >0) {2071if(get_oid_hex(sb.buf, &abort_safety))2072die(_("could not parse%s"),am_path(state,"abort-safety"));2073}else2074oidclr(&abort_safety);2075strbuf_release(&sb);20762077if(get_oid("HEAD", &head))2078oidclr(&head);20792080if(oideq(&head, &abort_safety))2081return1;20822083warning(_("You seem to have moved HEAD since the last 'am' failure.\n"2084"Not rewinding to ORIG_HEAD"));20852086return0;2087}20882089/**2090 * Aborts the current am session if it is safe to do so.2091 */2092static voidam_abort(struct am_state *state)2093{2094struct object_id curr_head, orig_head;2095int has_curr_head, has_orig_head;2096char*curr_branch;20972098if(!safe_to_abort(state)) {2099am_destroy(state);2100return;2101}21022103am_rerere_clear();21042105 curr_branch =resolve_refdup("HEAD",0, &curr_head, NULL);2106 has_curr_head = curr_branch && !is_null_oid(&curr_head);2107if(!has_curr_head)2108oidcpy(&curr_head, the_hash_algo->empty_tree);21092110 has_orig_head = !get_oid("ORIG_HEAD", &orig_head);2111if(!has_orig_head)2112oidcpy(&orig_head, the_hash_algo->empty_tree);21132114clean_index(&curr_head, &orig_head);21152116if(has_orig_head)2117update_ref("am --abort","HEAD", &orig_head,2118 has_curr_head ? &curr_head : NULL,0,2119 UPDATE_REFS_DIE_ON_ERR);2120else if(curr_branch)2121delete_ref(NULL, curr_branch, NULL, REF_NO_DEREF);21222123free(curr_branch);2124am_destroy(state);2125}21262127static intshow_patch(struct am_state *state)2128{2129struct strbuf sb = STRBUF_INIT;2130const char*patch_path;2131int len;21322133if(!is_null_oid(&state->orig_commit)) {2134const char*av[4] = {"show", NULL,"--", NULL };2135char*new_oid_str;2136int ret;21372138 av[1] = new_oid_str =xstrdup(oid_to_hex(&state->orig_commit));2139 ret =run_command_v_opt(av, RUN_GIT_CMD);2140free(new_oid_str);2141return ret;2142}21432144 patch_path =am_path(state,msgnum(state));2145 len =strbuf_read_file(&sb, patch_path,0);2146if(len <0)2147die_errno(_("failed to read '%s'"), patch_path);21482149setup_pager();2150write_in_full(1, sb.buf, sb.len);2151strbuf_release(&sb);2152return0;2153}21542155/**2156 * parse_options() callback that validates and sets opt->value to the2157 * PATCH_FORMAT_* enum value corresponding to `arg`.2158 */2159static intparse_opt_patchformat(const struct option *opt,const char*arg,int unset)2160{2161int*opt_value = opt->value;21622163if(!strcmp(arg,"mbox"))2164*opt_value = PATCH_FORMAT_MBOX;2165else if(!strcmp(arg,"stgit"))2166*opt_value = PATCH_FORMAT_STGIT;2167else if(!strcmp(arg,"stgit-series"))2168*opt_value = PATCH_FORMAT_STGIT_SERIES;2169else if(!strcmp(arg,"hg"))2170*opt_value = PATCH_FORMAT_HG;2171else if(!strcmp(arg,"mboxrd"))2172*opt_value = PATCH_FORMAT_MBOXRD;2173else2174returnerror(_("Invalid value for --patch-format:%s"), arg);2175return0;2176}21772178enum resume_mode {2179 RESUME_FALSE =0,2180 RESUME_APPLY,2181 RESUME_RESOLVED,2182 RESUME_SKIP,2183 RESUME_ABORT,2184 RESUME_QUIT,2185 RESUME_SHOW_PATCH2186};21872188static intgit_am_config(const char*k,const char*v,void*cb)2189{2190int status;21912192 status =git_gpg_config(k, v, NULL);2193if(status)2194return status;21952196returngit_default_config(k, v, NULL);2197}21982199intcmd_am(int argc,const char**argv,const char*prefix)2200{2201struct am_state state;2202int binary = -1;2203int keep_cr = -1;2204int patch_format = PATCH_FORMAT_UNKNOWN;2205enum resume_mode resume = RESUME_FALSE;2206int in_progress;2207int ret =0;22082209const char*const usage[] = {2210N_("git am [<options>] [(<mbox> | <Maildir>)...]"),2211N_("git am [<options>] (--continue | --skip | --abort)"),2212 NULL2213};22142215struct option options[] = {2216OPT_BOOL('i',"interactive", &state.interactive,2217N_("run interactively")),2218OPT_HIDDEN_BOOL('b',"binary", &binary,2219N_("historical option -- no-op")),2220OPT_BOOL('3',"3way", &state.threeway,2221N_("allow fall back on 3way merging if needed")),2222OPT__QUIET(&state.quiet,N_("be quiet")),2223OPT_SET_INT('s',"signoff", &state.signoff,2224N_("add a Signed-off-by line to the commit message"),2225 SIGNOFF_EXPLICIT),2226OPT_BOOL('u',"utf8", &state.utf8,2227N_("recode into utf8 (default)")),2228OPT_SET_INT('k',"keep", &state.keep,2229N_("pass -k flag to git-mailinfo"), KEEP_TRUE),2230OPT_SET_INT(0,"keep-non-patch", &state.keep,2231N_("pass -b flag to git-mailinfo"), KEEP_NON_PATCH),2232OPT_BOOL('m',"message-id", &state.message_id,2233N_("pass -m flag to git-mailinfo")),2234OPT_SET_INT_F(0,"keep-cr", &keep_cr,2235N_("pass --keep-cr flag to git-mailsplit for mbox format"),22361, PARSE_OPT_NONEG),2237OPT_SET_INT_F(0,"no-keep-cr", &keep_cr,2238N_("do not pass --keep-cr flag to git-mailsplit independent of am.keepcr"),22390, PARSE_OPT_NONEG),2240OPT_BOOL('c',"scissors", &state.scissors,2241N_("strip everything before a scissors line")),2242OPT_PASSTHRU_ARGV(0,"whitespace", &state.git_apply_opts,N_("action"),2243N_("pass it through git-apply"),22440),2245OPT_PASSTHRU_ARGV(0,"ignore-space-change", &state.git_apply_opts, NULL,2246N_("pass it through git-apply"),2247 PARSE_OPT_NOARG),2248OPT_PASSTHRU_ARGV(0,"ignore-whitespace", &state.git_apply_opts, NULL,2249N_("pass it through git-apply"),2250 PARSE_OPT_NOARG),2251OPT_PASSTHRU_ARGV(0,"directory", &state.git_apply_opts,N_("root"),2252N_("pass it through git-apply"),22530),2254OPT_PASSTHRU_ARGV(0,"exclude", &state.git_apply_opts,N_("path"),2255N_("pass it through git-apply"),22560),2257OPT_PASSTHRU_ARGV(0,"include", &state.git_apply_opts,N_("path"),2258N_("pass it through git-apply"),22590),2260OPT_PASSTHRU_ARGV('C', NULL, &state.git_apply_opts,N_("n"),2261N_("pass it through git-apply"),22620),2263OPT_PASSTHRU_ARGV('p', NULL, &state.git_apply_opts,N_("num"),2264N_("pass it through git-apply"),22650),2266OPT_CALLBACK(0,"patch-format", &patch_format,N_("format"),2267N_("format the patch(es) are in"),2268 parse_opt_patchformat),2269OPT_PASSTHRU_ARGV(0,"reject", &state.git_apply_opts, NULL,2270N_("pass it through git-apply"),2271 PARSE_OPT_NOARG),2272OPT_STRING(0,"resolvemsg", &state.resolvemsg, NULL,2273N_("override error message when patch failure occurs")),2274OPT_CMDMODE(0,"continue", &resume,2275N_("continue applying patches after resolving a conflict"),2276 RESUME_RESOLVED),2277OPT_CMDMODE('r',"resolved", &resume,2278N_("synonyms for --continue"),2279 RESUME_RESOLVED),2280OPT_CMDMODE(0,"skip", &resume,2281N_("skip the current patch"),2282 RESUME_SKIP),2283OPT_CMDMODE(0,"abort", &resume,2284N_("restore the original branch and abort the patching operation."),2285 RESUME_ABORT),2286OPT_CMDMODE(0,"quit", &resume,2287N_("abort the patching operation but keep HEAD where it is."),2288 RESUME_QUIT),2289OPT_CMDMODE(0,"show-current-patch", &resume,2290N_("show the patch being applied."),2291 RESUME_SHOW_PATCH),2292OPT_BOOL(0,"committer-date-is-author-date",2293&state.committer_date_is_author_date,2294N_("lie about committer date")),2295OPT_BOOL(0,"ignore-date", &state.ignore_date,2296N_("use current timestamp for author date")),2297OPT_RERERE_AUTOUPDATE(&state.allow_rerere_autoupdate),2298{ OPTION_STRING,'S',"gpg-sign", &state.sign_commit,N_("key-id"),2299N_("GPG-sign commits"),2300 PARSE_OPT_OPTARG, NULL, (intptr_t)""},2301OPT_HIDDEN_BOOL(0,"rebasing", &state.rebasing,2302N_("(internal use for git-rebase)")),2303OPT_END()2304};23052306if(argc ==2&& !strcmp(argv[1],"-h"))2307usage_with_options(usage, options);23082309git_config(git_am_config, NULL);23102311am_state_init(&state);23122313 in_progress =am_in_progress(&state);2314if(in_progress)2315am_load(&state);23162317 argc =parse_options(argc, argv, prefix, options, usage,0);23182319if(binary >=0)2320fprintf_ln(stderr,_("The -b/--binary option has been a no-op for long time, and\n"2321"it will be removed. Please do not use it anymore."));23222323/* Ensure a valid committer ident can be constructed */2324git_committer_info(IDENT_STRICT);23252326if(read_index_preload(&the_index, NULL) <0)2327die(_("failed to read the index"));23282329if(in_progress) {2330/*2331 * Catch user error to feed us patches when there is a session2332 * in progress:2333 *2334 * 1. mbox path(s) are provided on the command-line.2335 * 2. stdin is not a tty: the user is trying to feed us a patch2336 * from standard input. This is somewhat unreliable -- stdin2337 * could be /dev/null for example and the caller did not2338 * intend to feed us a patch but wanted to continue2339 * unattended.2340 */2341if(argc || (resume == RESUME_FALSE && !isatty(0)))2342die(_("previous rebase directory%sstill exists but mbox given."),2343 state.dir);23442345if(resume == RESUME_FALSE)2346 resume = RESUME_APPLY;23472348if(state.signoff == SIGNOFF_EXPLICIT)2349am_append_signoff(&state);2350}else{2351struct argv_array paths = ARGV_ARRAY_INIT;2352int i;23532354/*2355 * Handle stray state directory in the independent-run case. In2356 * the --rebasing case, it is up to the caller to take care of2357 * stray directories.2358 */2359if(file_exists(state.dir) && !state.rebasing) {2360if(resume == RESUME_ABORT || resume == RESUME_QUIT) {2361am_destroy(&state);2362am_state_release(&state);2363return0;2364}23652366die(_("Stray%sdirectory found.\n"2367"Use\"git am --abort\"to remove it."),2368 state.dir);2369}23702371if(resume)2372die(_("Resolve operation not in progress, we are not resuming."));23732374for(i =0; i < argc; i++) {2375if(is_absolute_path(argv[i]) || !prefix)2376argv_array_push(&paths, argv[i]);2377else2378argv_array_push(&paths,mkpath("%s/%s", prefix, argv[i]));2379}23802381am_setup(&state, patch_format, paths.argv, keep_cr);23822383argv_array_clear(&paths);2384}23852386switch(resume) {2387case RESUME_FALSE:2388am_run(&state,0);2389break;2390case RESUME_APPLY:2391am_run(&state,1);2392break;2393case RESUME_RESOLVED:2394am_resolve(&state);2395break;2396case RESUME_SKIP:2397am_skip(&state);2398break;2399case RESUME_ABORT:2400am_abort(&state);2401break;2402case RESUME_QUIT:2403am_rerere_clear();2404am_destroy(&state);2405break;2406case RESUME_SHOW_PATCH:2407 ret =show_patch(&state);2408break;2409default:2410BUG("invalid resume value");2411}24122413am_state_release(&state);24142415return ret;2416}