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 35/** 36 * Returns 1 if the file is empty or does not exist, 0 otherwise. 37 */ 38static intis_empty_file(const char*filename) 39{ 40struct stat st; 41 42if(stat(filename, &st) <0) { 43if(errno == ENOENT) 44return1; 45die_errno(_("could not stat%s"), filename); 46} 47 48return!st.st_size; 49} 50 51/** 52 * Returns the length of the first line of msg. 53 */ 54static intlinelen(const char*msg) 55{ 56returnstrchrnul(msg,'\n') - msg; 57} 58 59/** 60 * Returns true if `str` consists of only whitespace, false otherwise. 61 */ 62static intstr_isspace(const char*str) 63{ 64for(; *str; str++) 65if(!isspace(*str)) 66return0; 67 68return1; 69} 70 71enum patch_format { 72 PATCH_FORMAT_UNKNOWN =0, 73 PATCH_FORMAT_MBOX, 74 PATCH_FORMAT_STGIT, 75 PATCH_FORMAT_STGIT_SERIES, 76 PATCH_FORMAT_HG, 77 PATCH_FORMAT_MBOXRD 78}; 79 80enum keep_type { 81 KEEP_FALSE =0, 82 KEEP_TRUE,/* pass -k flag to git-mailinfo */ 83 KEEP_NON_PATCH /* pass -b flag to git-mailinfo */ 84}; 85 86enum scissors_type { 87 SCISSORS_UNSET = -1, 88 SCISSORS_FALSE =0,/* pass --no-scissors to git-mailinfo */ 89 SCISSORS_TRUE /* pass --scissors to git-mailinfo */ 90}; 91 92enum signoff_type { 93 SIGNOFF_FALSE =0, 94 SIGNOFF_TRUE =1, 95 SIGNOFF_EXPLICIT /* --signoff was set on the command-line */ 96}; 97 98struct am_state { 99/* state directory path */ 100char*dir; 101 102/* current and last patch numbers, 1-indexed */ 103int cur; 104int last; 105 106/* commit metadata and message */ 107char*author_name; 108char*author_email; 109char*author_date; 110char*msg; 111size_t msg_len; 112 113/* when --rebasing, records the original commit the patch came from */ 114struct object_id orig_commit; 115 116/* number of digits in patch filename */ 117int prec; 118 119/* various operating modes and command line options */ 120int interactive; 121int threeway; 122int quiet; 123int signoff;/* enum signoff_type */ 124int utf8; 125int keep;/* enum keep_type */ 126int message_id; 127int scissors;/* enum scissors_type */ 128struct argv_array git_apply_opts; 129const char*resolvemsg; 130int committer_date_is_author_date; 131int ignore_date; 132int allow_rerere_autoupdate; 133const char*sign_commit; 134int rebasing; 135}; 136 137/** 138 * Initializes am_state with the default values. 139 */ 140static voidam_state_init(struct am_state *state) 141{ 142int gpgsign; 143 144memset(state,0,sizeof(*state)); 145 146 state->dir =git_pathdup("rebase-apply"); 147 148 state->prec =4; 149 150git_config_get_bool("am.threeway", &state->threeway); 151 152 state->utf8 =1; 153 154git_config_get_bool("am.messageid", &state->message_id); 155 156 state->scissors = SCISSORS_UNSET; 157 158argv_array_init(&state->git_apply_opts); 159 160if(!git_config_get_bool("commit.gpgsign", &gpgsign)) 161 state->sign_commit = gpgsign ?"": NULL; 162} 163 164/** 165 * Releases memory allocated by an am_state. 166 */ 167static voidam_state_release(struct am_state *state) 168{ 169free(state->dir); 170free(state->author_name); 171free(state->author_email); 172free(state->author_date); 173free(state->msg); 174argv_array_clear(&state->git_apply_opts); 175} 176 177/** 178 * Returns path relative to the am_state directory. 179 */ 180staticinlineconst char*am_path(const struct am_state *state,const char*path) 181{ 182returnmkpath("%s/%s", state->dir, path); 183} 184 185/** 186 * For convenience to call write_file() 187 */ 188static voidwrite_state_text(const struct am_state *state, 189const char*name,const char*string) 190{ 191write_file(am_path(state, name),"%s", string); 192} 193 194static voidwrite_state_count(const struct am_state *state, 195const char*name,int value) 196{ 197write_file(am_path(state, name),"%d", value); 198} 199 200static voidwrite_state_bool(const struct am_state *state, 201const char*name,int value) 202{ 203write_state_text(state, name, value ?"t":"f"); 204} 205 206/** 207 * If state->quiet is false, calls fprintf(fp, fmt, ...), and appends a newline 208 * at the end. 209 */ 210static voidsay(const struct am_state *state,FILE*fp,const char*fmt, ...) 211{ 212va_list ap; 213 214va_start(ap, fmt); 215if(!state->quiet) { 216vfprintf(fp, fmt, ap); 217putc('\n', fp); 218} 219va_end(ap); 220} 221 222/** 223 * Returns 1 if there is an am session in progress, 0 otherwise. 224 */ 225static intam_in_progress(const struct am_state *state) 226{ 227struct stat st; 228 229if(lstat(state->dir, &st) <0|| !S_ISDIR(st.st_mode)) 230return0; 231if(lstat(am_path(state,"last"), &st) || !S_ISREG(st.st_mode)) 232return0; 233if(lstat(am_path(state,"next"), &st) || !S_ISREG(st.st_mode)) 234return0; 235return1; 236} 237 238/** 239 * Reads the contents of `file` in the `state` directory into `sb`. Returns the 240 * number of bytes read on success, -1 if the file does not exist. If `trim` is 241 * set, trailing whitespace will be removed. 242 */ 243static intread_state_file(struct strbuf *sb,const struct am_state *state, 244const char*file,int trim) 245{ 246strbuf_reset(sb); 247 248if(strbuf_read_file(sb,am_path(state, file),0) >=0) { 249if(trim) 250strbuf_trim(sb); 251 252return sb->len; 253} 254 255if(errno == ENOENT) 256return-1; 257 258die_errno(_("could not read '%s'"),am_path(state, file)); 259} 260 261/** 262 * Take a series of KEY='VALUE' lines where VALUE part is 263 * sq-quoted, and append <KEY, VALUE> at the end of the string list 264 */ 265static intparse_key_value_squoted(char*buf,struct string_list *list) 266{ 267while(*buf) { 268struct string_list_item *item; 269char*np; 270char*cp =strchr(buf,'='); 271if(!cp) 272return-1; 273 np =strchrnul(cp,'\n'); 274*cp++ ='\0'; 275 item =string_list_append(list, buf); 276 277 buf = np + (*np =='\n'); 278*np ='\0'; 279 cp =sq_dequote(cp); 280if(!cp) 281return-1; 282 item->util =xstrdup(cp); 283} 284return0; 285} 286 287/** 288 * Reads and parses the state directory's "author-script" file, and sets 289 * state->author_name, state->author_email and state->author_date accordingly. 290 * Returns 0 on success, -1 if the file could not be parsed. 291 * 292 * The author script is of the format: 293 * 294 * GIT_AUTHOR_NAME='$author_name' 295 * GIT_AUTHOR_EMAIL='$author_email' 296 * GIT_AUTHOR_DATE='$author_date' 297 * 298 * where $author_name, $author_email and $author_date are quoted. We are strict 299 * with our parsing, as the file was meant to be eval'd in the old git-am.sh 300 * script, and thus if the file differs from what this function expects, it is 301 * better to bail out than to do something that the user does not expect. 302 */ 303static intread_author_script(struct am_state *state) 304{ 305const char*filename =am_path(state,"author-script"); 306struct strbuf buf = STRBUF_INIT; 307struct string_list kv = STRING_LIST_INIT_DUP; 308int retval = -1;/* assume failure */ 309int fd; 310 311assert(!state->author_name); 312assert(!state->author_email); 313assert(!state->author_date); 314 315 fd =open(filename, O_RDONLY); 316if(fd <0) { 317if(errno == ENOENT) 318return0; 319die_errno(_("could not open '%s' for reading"), filename); 320} 321strbuf_read(&buf, fd,0); 322close(fd); 323if(parse_key_value_squoted(buf.buf, &kv)) 324goto finish; 325 326if(kv.nr !=3|| 327strcmp(kv.items[0].string,"GIT_AUTHOR_NAME") || 328strcmp(kv.items[1].string,"GIT_AUTHOR_EMAIL") || 329strcmp(kv.items[2].string,"GIT_AUTHOR_DATE")) 330goto finish; 331 state->author_name = kv.items[0].util; 332 state->author_email = kv.items[1].util; 333 state->author_date = kv.items[2].util; 334 retval =0; 335finish: 336string_list_clear(&kv, !!retval); 337strbuf_release(&buf); 338return retval; 339} 340 341/** 342 * Saves state->author_name, state->author_email and state->author_date in the 343 * state directory's "author-script" file. 344 */ 345static voidwrite_author_script(const struct am_state *state) 346{ 347struct strbuf sb = STRBUF_INIT; 348 349strbuf_addstr(&sb,"GIT_AUTHOR_NAME="); 350sq_quote_buf(&sb, state->author_name); 351strbuf_addch(&sb,'\n'); 352 353strbuf_addstr(&sb,"GIT_AUTHOR_EMAIL="); 354sq_quote_buf(&sb, state->author_email); 355strbuf_addch(&sb,'\n'); 356 357strbuf_addstr(&sb,"GIT_AUTHOR_DATE="); 358sq_quote_buf(&sb, state->author_date); 359strbuf_addch(&sb,'\n'); 360 361write_state_text(state,"author-script", sb.buf); 362 363strbuf_release(&sb); 364} 365 366/** 367 * Reads the commit message from the state directory's "final-commit" file, 368 * setting state->msg to its contents and state->msg_len to the length of its 369 * contents in bytes. 370 * 371 * Returns 0 on success, -1 if the file does not exist. 372 */ 373static intread_commit_msg(struct am_state *state) 374{ 375struct strbuf sb = STRBUF_INIT; 376 377assert(!state->msg); 378 379if(read_state_file(&sb, state,"final-commit",0) <0) { 380strbuf_release(&sb); 381return-1; 382} 383 384 state->msg =strbuf_detach(&sb, &state->msg_len); 385return0; 386} 387 388/** 389 * Saves state->msg in the state directory's "final-commit" file. 390 */ 391static voidwrite_commit_msg(const struct am_state *state) 392{ 393const char*filename =am_path(state,"final-commit"); 394write_file_buf(filename, state->msg, state->msg_len); 395} 396 397/** 398 * Loads state from disk. 399 */ 400static voidam_load(struct am_state *state) 401{ 402struct strbuf sb = STRBUF_INIT; 403 404if(read_state_file(&sb, state,"next",1) <0) 405die("BUG: state file 'next' does not exist"); 406 state->cur =strtol(sb.buf, NULL,10); 407 408if(read_state_file(&sb, state,"last",1) <0) 409die("BUG: state file 'last' does not exist"); 410 state->last =strtol(sb.buf, NULL,10); 411 412if(read_author_script(state) <0) 413die(_("could not parse author script")); 414 415read_commit_msg(state); 416 417if(read_state_file(&sb, state,"original-commit",1) <0) 418oidclr(&state->orig_commit); 419else if(get_oid_hex(sb.buf, &state->orig_commit) <0) 420die(_("could not parse%s"),am_path(state,"original-commit")); 421 422read_state_file(&sb, state,"threeway",1); 423 state->threeway = !strcmp(sb.buf,"t"); 424 425read_state_file(&sb, state,"quiet",1); 426 state->quiet = !strcmp(sb.buf,"t"); 427 428read_state_file(&sb, state,"sign",1); 429 state->signoff = !strcmp(sb.buf,"t"); 430 431read_state_file(&sb, state,"utf8",1); 432 state->utf8 = !strcmp(sb.buf,"t"); 433 434read_state_file(&sb, state,"keep",1); 435if(!strcmp(sb.buf,"t")) 436 state->keep = KEEP_TRUE; 437else if(!strcmp(sb.buf,"b")) 438 state->keep = KEEP_NON_PATCH; 439else 440 state->keep = KEEP_FALSE; 441 442read_state_file(&sb, state,"messageid",1); 443 state->message_id = !strcmp(sb.buf,"t"); 444 445read_state_file(&sb, state,"scissors",1); 446if(!strcmp(sb.buf,"t")) 447 state->scissors = SCISSORS_TRUE; 448else if(!strcmp(sb.buf,"f")) 449 state->scissors = SCISSORS_FALSE; 450else 451 state->scissors = SCISSORS_UNSET; 452 453read_state_file(&sb, state,"apply-opt",1); 454argv_array_clear(&state->git_apply_opts); 455if(sq_dequote_to_argv_array(sb.buf, &state->git_apply_opts) <0) 456die(_("could not parse%s"),am_path(state,"apply-opt")); 457 458 state->rebasing = !!file_exists(am_path(state,"rebasing")); 459 460strbuf_release(&sb); 461} 462 463/** 464 * Removes the am_state directory, forcefully terminating the current am 465 * session. 466 */ 467static voidam_destroy(const struct am_state *state) 468{ 469struct strbuf sb = STRBUF_INIT; 470 471strbuf_addstr(&sb, state->dir); 472remove_dir_recursively(&sb,0); 473strbuf_release(&sb); 474} 475 476/** 477 * Runs applypatch-msg hook. Returns its exit code. 478 */ 479static intrun_applypatch_msg_hook(struct am_state *state) 480{ 481int ret; 482 483assert(state->msg); 484 ret =run_hook_le(NULL,"applypatch-msg",am_path(state,"final-commit"), NULL); 485 486if(!ret) { 487free(state->msg); 488 state->msg = NULL; 489if(read_commit_msg(state) <0) 490die(_("'%s' was deleted by the applypatch-msg hook"), 491am_path(state,"final-commit")); 492} 493 494return ret; 495} 496 497/** 498 * Runs post-rewrite hook. Returns it exit code. 499 */ 500static intrun_post_rewrite_hook(const struct am_state *state) 501{ 502struct child_process cp = CHILD_PROCESS_INIT; 503const char*hook =find_hook("post-rewrite"); 504int ret; 505 506if(!hook) 507return0; 508 509argv_array_push(&cp.args, hook); 510argv_array_push(&cp.args,"rebase"); 511 512 cp.in =xopen(am_path(state,"rewritten"), O_RDONLY); 513 cp.stdout_to_stderr =1; 514 515 ret =run_command(&cp); 516 517close(cp.in); 518return ret; 519} 520 521/** 522 * Reads the state directory's "rewritten" file, and copies notes from the old 523 * commits listed in the file to their rewritten commits. 524 * 525 * Returns 0 on success, -1 on failure. 526 */ 527static intcopy_notes_for_rebase(const struct am_state *state) 528{ 529struct notes_rewrite_cfg *c; 530struct strbuf sb = STRBUF_INIT; 531const char*invalid_line =_("Malformed input line: '%s'."); 532const char*msg ="Notes added by 'git rebase'"; 533FILE*fp; 534int ret =0; 535 536assert(state->rebasing); 537 538 c =init_copy_notes_for_rewrite("rebase"); 539if(!c) 540return0; 541 542 fp =xfopen(am_path(state,"rewritten"),"r"); 543 544while(!strbuf_getline_lf(&sb, fp)) { 545struct object_id from_obj, to_obj; 546 547if(sb.len != GIT_SHA1_HEXSZ *2+1) { 548 ret =error(invalid_line, sb.buf); 549goto finish; 550} 551 552if(get_oid_hex(sb.buf, &from_obj)) { 553 ret =error(invalid_line, sb.buf); 554goto finish; 555} 556 557if(sb.buf[GIT_SHA1_HEXSZ] !=' ') { 558 ret =error(invalid_line, sb.buf); 559goto finish; 560} 561 562if(get_oid_hex(sb.buf + GIT_SHA1_HEXSZ +1, &to_obj)) { 563 ret =error(invalid_line, sb.buf); 564goto finish; 565} 566 567if(copy_note_for_rewrite(c, &from_obj, &to_obj)) 568 ret =error(_("Failed to copy notes from '%s' to '%s'"), 569oid_to_hex(&from_obj),oid_to_hex(&to_obj)); 570} 571 572finish: 573finish_copy_notes_for_rewrite(c, msg); 574fclose(fp); 575strbuf_release(&sb); 576return ret; 577} 578 579/** 580 * Determines if the file looks like a piece of RFC2822 mail by grabbing all 581 * non-indented lines and checking if they look like they begin with valid 582 * header field names. 583 * 584 * Returns 1 if the file looks like a piece of mail, 0 otherwise. 585 */ 586static intis_mail(FILE*fp) 587{ 588const char*header_regex ="^[!-9;-~]+:"; 589struct strbuf sb = STRBUF_INIT; 590 regex_t regex; 591int ret =1; 592 593if(fseek(fp,0L, SEEK_SET)) 594die_errno(_("fseek failed")); 595 596if(regcomp(®ex, header_regex, REG_NOSUB | REG_EXTENDED)) 597die("invalid pattern:%s", header_regex); 598 599while(!strbuf_getline(&sb, fp)) { 600if(!sb.len) 601break;/* End of header */ 602 603/* Ignore indented folded lines */ 604if(*sb.buf =='\t'|| *sb.buf ==' ') 605continue; 606 607/* It's a header if it matches header_regex */ 608if(regexec(®ex, sb.buf,0, NULL,0)) { 609 ret =0; 610goto done; 611} 612} 613 614done: 615regfree(®ex); 616strbuf_release(&sb); 617return ret; 618} 619 620/** 621 * Attempts to detect the patch_format of the patches contained in `paths`, 622 * returning the PATCH_FORMAT_* enum value. Returns PATCH_FORMAT_UNKNOWN if 623 * detection fails. 624 */ 625static intdetect_patch_format(const char**paths) 626{ 627enum patch_format ret = PATCH_FORMAT_UNKNOWN; 628struct strbuf l1 = STRBUF_INIT; 629struct strbuf l2 = STRBUF_INIT; 630struct strbuf l3 = STRBUF_INIT; 631FILE*fp; 632 633/* 634 * We default to mbox format if input is from stdin and for directories 635 */ 636if(!*paths || !strcmp(*paths,"-") ||is_directory(*paths)) 637return PATCH_FORMAT_MBOX; 638 639/* 640 * Otherwise, check the first few lines of the first patch, starting 641 * from the first non-blank line, to try to detect its format. 642 */ 643 644 fp =xfopen(*paths,"r"); 645 646while(!strbuf_getline(&l1, fp)) { 647if(l1.len) 648break; 649} 650 651if(starts_with(l1.buf,"From ") ||starts_with(l1.buf,"From: ")) { 652 ret = PATCH_FORMAT_MBOX; 653goto done; 654} 655 656if(starts_with(l1.buf,"# This series applies on GIT commit")) { 657 ret = PATCH_FORMAT_STGIT_SERIES; 658goto done; 659} 660 661if(!strcmp(l1.buf,"# HG changeset patch")) { 662 ret = PATCH_FORMAT_HG; 663goto done; 664} 665 666strbuf_reset(&l2); 667strbuf_getline(&l2, fp); 668strbuf_reset(&l3); 669strbuf_getline(&l3, fp); 670 671/* 672 * If the second line is empty and the third is a From, Author or Date 673 * entry, this is likely an StGit patch. 674 */ 675if(l1.len && !l2.len && 676(starts_with(l3.buf,"From:") || 677starts_with(l3.buf,"Author:") || 678starts_with(l3.buf,"Date:"))) { 679 ret = PATCH_FORMAT_STGIT; 680goto done; 681} 682 683if(l1.len &&is_mail(fp)) { 684 ret = PATCH_FORMAT_MBOX; 685goto done; 686} 687 688done: 689fclose(fp); 690strbuf_release(&l1); 691return ret; 692} 693 694/** 695 * Splits out individual email patches from `paths`, where each path is either 696 * a mbox file or a Maildir. Returns 0 on success, -1 on failure. 697 */ 698static intsplit_mail_mbox(struct am_state *state,const char**paths, 699int keep_cr,int mboxrd) 700{ 701struct child_process cp = CHILD_PROCESS_INIT; 702struct strbuf last = STRBUF_INIT; 703 704 cp.git_cmd =1; 705argv_array_push(&cp.args,"mailsplit"); 706argv_array_pushf(&cp.args,"-d%d", state->prec); 707argv_array_pushf(&cp.args,"-o%s", state->dir); 708argv_array_push(&cp.args,"-b"); 709if(keep_cr) 710argv_array_push(&cp.args,"--keep-cr"); 711if(mboxrd) 712argv_array_push(&cp.args,"--mboxrd"); 713argv_array_push(&cp.args,"--"); 714argv_array_pushv(&cp.args, paths); 715 716if(capture_command(&cp, &last,8)) 717return-1; 718 719 state->cur =1; 720 state->last =strtol(last.buf, NULL,10); 721 722return0; 723} 724 725/** 726 * Callback signature for split_mail_conv(). The foreign patch should be 727 * read from `in`, and the converted patch (in RFC2822 mail format) should be 728 * written to `out`. Return 0 on success, or -1 on failure. 729 */ 730typedefint(*mail_conv_fn)(FILE*out,FILE*in,int keep_cr); 731 732/** 733 * Calls `fn` for each file in `paths` to convert the foreign patch to the 734 * RFC2822 mail format suitable for parsing with git-mailinfo. 735 * 736 * Returns 0 on success, -1 on failure. 737 */ 738static intsplit_mail_conv(mail_conv_fn fn,struct am_state *state, 739const char**paths,int keep_cr) 740{ 741static const char*stdin_only[] = {"-", NULL}; 742int i; 743 744if(!*paths) 745 paths = stdin_only; 746 747for(i =0; *paths; paths++, i++) { 748FILE*in, *out; 749const char*mail; 750int ret; 751 752if(!strcmp(*paths,"-")) 753 in = stdin; 754else 755 in =fopen(*paths,"r"); 756 757if(!in) 758returnerror_errno(_("could not open '%s' for reading"), 759*paths); 760 761 mail =mkpath("%s/%0*d", state->dir, state->prec, i +1); 762 763 out =fopen(mail,"w"); 764if(!out) { 765if(in != stdin) 766fclose(in); 767returnerror_errno(_("could not open '%s' for writing"), 768 mail); 769} 770 771 ret =fn(out, in, keep_cr); 772 773fclose(out); 774if(in != stdin) 775fclose(in); 776 777if(ret) 778returnerror(_("could not parse patch '%s'"), *paths); 779} 780 781 state->cur =1; 782 state->last = i; 783return0; 784} 785 786/** 787 * A split_mail_conv() callback that converts an StGit patch to an RFC2822 788 * message suitable for parsing with git-mailinfo. 789 */ 790static intstgit_patch_to_mail(FILE*out,FILE*in,int keep_cr) 791{ 792struct strbuf sb = STRBUF_INIT; 793int subject_printed =0; 794 795while(!strbuf_getline_lf(&sb, in)) { 796const char*str; 797 798if(str_isspace(sb.buf)) 799continue; 800else if(skip_prefix(sb.buf,"Author:", &str)) 801fprintf(out,"From:%s\n", str); 802else if(starts_with(sb.buf,"From") ||starts_with(sb.buf,"Date")) 803fprintf(out,"%s\n", sb.buf); 804else if(!subject_printed) { 805fprintf(out,"Subject:%s\n", sb.buf); 806 subject_printed =1; 807}else{ 808fprintf(out,"\n%s\n", sb.buf); 809break; 810} 811} 812 813strbuf_reset(&sb); 814while(strbuf_fread(&sb,8192, in) >0) { 815fwrite(sb.buf,1, sb.len, out); 816strbuf_reset(&sb); 817} 818 819strbuf_release(&sb); 820return0; 821} 822 823/** 824 * This function only supports a single StGit series file in `paths`. 825 * 826 * Given an StGit series file, converts the StGit patches in the series into 827 * RFC2822 messages suitable for parsing with git-mailinfo, and queues them in 828 * the state directory. 829 * 830 * Returns 0 on success, -1 on failure. 831 */ 832static intsplit_mail_stgit_series(struct am_state *state,const char**paths, 833int keep_cr) 834{ 835const char*series_dir; 836char*series_dir_buf; 837FILE*fp; 838struct argv_array patches = ARGV_ARRAY_INIT; 839struct strbuf sb = STRBUF_INIT; 840int ret; 841 842if(!paths[0] || paths[1]) 843returnerror(_("Only one StGIT patch series can be applied at once")); 844 845 series_dir_buf =xstrdup(*paths); 846 series_dir =dirname(series_dir_buf); 847 848 fp =fopen(*paths,"r"); 849if(!fp) 850returnerror_errno(_("could not open '%s' for reading"), *paths); 851 852while(!strbuf_getline_lf(&sb, fp)) { 853if(*sb.buf =='#') 854continue;/* skip comment lines */ 855 856argv_array_push(&patches,mkpath("%s/%s", series_dir, sb.buf)); 857} 858 859fclose(fp); 860strbuf_release(&sb); 861free(series_dir_buf); 862 863 ret =split_mail_conv(stgit_patch_to_mail, state, patches.argv, keep_cr); 864 865argv_array_clear(&patches); 866return ret; 867} 868 869/** 870 * A split_patches_conv() callback that converts a mercurial patch to a RFC2822 871 * message suitable for parsing with git-mailinfo. 872 */ 873static inthg_patch_to_mail(FILE*out,FILE*in,int keep_cr) 874{ 875struct strbuf sb = STRBUF_INIT; 876 877while(!strbuf_getline_lf(&sb, in)) { 878const char*str; 879 880if(skip_prefix(sb.buf,"# User ", &str)) 881fprintf(out,"From:%s\n", str); 882else if(skip_prefix(sb.buf,"# Date ", &str)) { 883 timestamp_t timestamp; 884long tz, tz2; 885char*end; 886 887 errno =0; 888 timestamp =parse_timestamp(str, &end,10); 889if(errno) 890returnerror(_("invalid timestamp")); 891 892if(!skip_prefix(end," ", &str)) 893returnerror(_("invalid Date line")); 894 895 errno =0; 896 tz =strtol(str, &end,10); 897if(errno) 898returnerror(_("invalid timezone offset")); 899 900if(*end) 901returnerror(_("invalid Date line")); 902 903/* 904 * mercurial's timezone is in seconds west of UTC, 905 * however git's timezone is in hours + minutes east of 906 * UTC. Convert it. 907 */ 908 tz2 =labs(tz) /3600*100+labs(tz) %3600/60; 909if(tz >0) 910 tz2 = -tz2; 911 912fprintf(out,"Date:%s\n",show_date(timestamp, tz2,DATE_MODE(RFC2822))); 913}else if(starts_with(sb.buf,"# ")) { 914continue; 915}else{ 916fprintf(out,"\n%s\n", sb.buf); 917break; 918} 919} 920 921strbuf_reset(&sb); 922while(strbuf_fread(&sb,8192, in) >0) { 923fwrite(sb.buf,1, sb.len, out); 924strbuf_reset(&sb); 925} 926 927strbuf_release(&sb); 928return0; 929} 930 931/** 932 * Splits a list of files/directories into individual email patches. Each path 933 * in `paths` must be a file/directory that is formatted according to 934 * `patch_format`. 935 * 936 * Once split out, the individual email patches will be stored in the state 937 * directory, with each patch's filename being its index, padded to state->prec 938 * digits. 939 * 940 * state->cur will be set to the index of the first mail, and state->last will 941 * be set to the index of the last mail. 942 * 943 * Set keep_cr to 0 to convert all lines ending with \r\n to end with \n, 1 944 * to disable this behavior, -1 to use the default configured setting. 945 * 946 * Returns 0 on success, -1 on failure. 947 */ 948static intsplit_mail(struct am_state *state,enum patch_format patch_format, 949const char**paths,int keep_cr) 950{ 951if(keep_cr <0) { 952 keep_cr =0; 953git_config_get_bool("am.keepcr", &keep_cr); 954} 955 956switch(patch_format) { 957case PATCH_FORMAT_MBOX: 958returnsplit_mail_mbox(state, paths, keep_cr,0); 959case PATCH_FORMAT_STGIT: 960returnsplit_mail_conv(stgit_patch_to_mail, state, paths, keep_cr); 961case PATCH_FORMAT_STGIT_SERIES: 962returnsplit_mail_stgit_series(state, paths, keep_cr); 963case PATCH_FORMAT_HG: 964returnsplit_mail_conv(hg_patch_to_mail, state, paths, keep_cr); 965case PATCH_FORMAT_MBOXRD: 966returnsplit_mail_mbox(state, paths, keep_cr,1); 967default: 968die("BUG: invalid patch_format"); 969} 970return-1; 971} 972 973/** 974 * Setup a new am session for applying patches 975 */ 976static voidam_setup(struct am_state *state,enum patch_format patch_format, 977const char**paths,int keep_cr) 978{ 979struct object_id curr_head; 980const char*str; 981struct strbuf sb = STRBUF_INIT; 982 983if(!patch_format) 984 patch_format =detect_patch_format(paths); 985 986if(!patch_format) { 987fprintf_ln(stderr,_("Patch format detection failed.")); 988exit(128); 989} 990 991if(mkdir(state->dir,0777) <0&& errno != EEXIST) 992die_errno(_("failed to create directory '%s'"), state->dir); 993 994if(split_mail(state, patch_format, paths, keep_cr) <0) { 995am_destroy(state); 996die(_("Failed to split patches.")); 997} 998 999if(state->rebasing)1000 state->threeway =1;10011002write_state_bool(state,"threeway", state->threeway);1003write_state_bool(state,"quiet", state->quiet);1004write_state_bool(state,"sign", state->signoff);1005write_state_bool(state,"utf8", state->utf8);10061007switch(state->keep) {1008case KEEP_FALSE:1009 str ="f";1010break;1011case KEEP_TRUE:1012 str ="t";1013break;1014case KEEP_NON_PATCH:1015 str ="b";1016break;1017default:1018die("BUG: invalid value for state->keep");1019}10201021write_state_text(state,"keep", str);1022write_state_bool(state,"messageid", state->message_id);10231024switch(state->scissors) {1025case SCISSORS_UNSET:1026 str ="";1027break;1028case SCISSORS_FALSE:1029 str ="f";1030break;1031case SCISSORS_TRUE:1032 str ="t";1033break;1034default:1035die("BUG: invalid value for state->scissors");1036}1037write_state_text(state,"scissors", str);10381039sq_quote_argv(&sb, state->git_apply_opts.argv,0);1040write_state_text(state,"apply-opt", sb.buf);10411042if(state->rebasing)1043write_state_text(state,"rebasing","");1044else1045write_state_text(state,"applying","");10461047if(!get_oid("HEAD", &curr_head)) {1048write_state_text(state,"abort-safety",oid_to_hex(&curr_head));1049if(!state->rebasing)1050update_ref_oid("am","ORIG_HEAD", &curr_head, NULL,0,1051 UPDATE_REFS_DIE_ON_ERR);1052}else{1053write_state_text(state,"abort-safety","");1054if(!state->rebasing)1055delete_ref(NULL,"ORIG_HEAD", NULL,0);1056}10571058/*1059 * NOTE: Since the "next" and "last" files determine if an am_state1060 * session is in progress, they should be written last.1061 */10621063write_state_count(state,"next", state->cur);1064write_state_count(state,"last", state->last);10651066strbuf_release(&sb);1067}10681069/**1070 * Increments the patch pointer, and cleans am_state for the application of the1071 * next patch.1072 */1073static voidam_next(struct am_state *state)1074{1075struct object_id head;10761077free(state->author_name);1078 state->author_name = NULL;10791080free(state->author_email);1081 state->author_email = NULL;10821083free(state->author_date);1084 state->author_date = NULL;10851086free(state->msg);1087 state->msg = NULL;1088 state->msg_len =0;10891090unlink(am_path(state,"author-script"));1091unlink(am_path(state,"final-commit"));10921093oidclr(&state->orig_commit);1094unlink(am_path(state,"original-commit"));10951096if(!get_oid("HEAD", &head))1097write_state_text(state,"abort-safety",oid_to_hex(&head));1098else1099write_state_text(state,"abort-safety","");11001101 state->cur++;1102write_state_count(state,"next", state->cur);1103}11041105/**1106 * Returns the filename of the current patch email.1107 */1108static const char*msgnum(const struct am_state *state)1109{1110static struct strbuf sb = STRBUF_INIT;11111112strbuf_reset(&sb);1113strbuf_addf(&sb,"%0*d", state->prec, state->cur);11141115return sb.buf;1116}11171118/**1119 * Refresh and write index.1120 */1121static voidrefresh_and_write_cache(void)1122{1123struct lock_file *lock_file =xcalloc(1,sizeof(struct lock_file));11241125hold_locked_index(lock_file, LOCK_DIE_ON_ERROR);1126refresh_cache(REFRESH_QUIET);1127if(write_locked_index(&the_index, lock_file, COMMIT_LOCK))1128die(_("unable to write index file"));1129}11301131/**1132 * Returns 1 if the index differs from HEAD, 0 otherwise. When on an unborn1133 * branch, returns 1 if there are entries in the index, 0 otherwise. If an1134 * strbuf is provided, the space-separated list of files that differ will be1135 * appended to it.1136 */1137static intindex_has_changes(struct strbuf *sb)1138{1139struct object_id head;1140int i;11411142if(!get_sha1_tree("HEAD", head.hash)) {1143struct diff_options opt;11441145diff_setup(&opt);1146DIFF_OPT_SET(&opt, EXIT_WITH_STATUS);1147if(!sb)1148DIFF_OPT_SET(&opt, QUICK);1149do_diff_cache(&head, &opt);1150diffcore_std(&opt);1151for(i =0; sb && i < diff_queued_diff.nr; i++) {1152if(i)1153strbuf_addch(sb,' ');1154strbuf_addstr(sb, diff_queued_diff.queue[i]->two->path);1155}1156diff_flush(&opt);1157returnDIFF_OPT_TST(&opt, HAS_CHANGES) !=0;1158}else{1159for(i =0; sb && i < active_nr; i++) {1160if(i)1161strbuf_addch(sb,' ');1162strbuf_addstr(sb, active_cache[i]->name);1163}1164return!!active_nr;1165}1166}11671168/**1169 * Dies with a user-friendly message on how to proceed after resolving the1170 * problem. This message can be overridden with state->resolvemsg.1171 */1172static void NORETURN die_user_resolve(const struct am_state *state)1173{1174if(state->resolvemsg) {1175printf_ln("%s", state->resolvemsg);1176}else{1177const char*cmdline = state->interactive ?"git am -i":"git am";11781179printf_ln(_("When you have resolved this problem, run\"%s--continue\"."), cmdline);1180printf_ln(_("If you prefer to skip this patch, run\"%s--skip\"instead."), cmdline);1181printf_ln(_("To restore the original branch and stop patching, run\"%s--abort\"."), cmdline);1182}11831184exit(128);1185}11861187/**1188 * Appends signoff to the "msg" field of the am_state.1189 */1190static voidam_append_signoff(struct am_state *state)1191{1192char*cp;1193struct strbuf mine = STRBUF_INIT;1194struct strbuf sb = STRBUF_INIT;11951196strbuf_attach(&sb, state->msg, state->msg_len, state->msg_len);11971198/* our sign-off */1199strbuf_addf(&mine,"\n%s%s\n",1200 sign_off_header,1201fmt_name(getenv("GIT_COMMITTER_NAME"),1202getenv("GIT_COMMITTER_EMAIL")));12031204/* Does sb end with it already? */1205if(mine.len < sb.len &&1206!strcmp(mine.buf, sb.buf + sb.len - mine.len))1207goto exit;/* no need to duplicate */12081209/* Does it have any Signed-off-by: in the text */1210for(cp = sb.buf;1211 cp && *cp && (cp =strstr(cp, sign_off_header)) != NULL;1212 cp =strchr(cp,'\n')) {1213if(sb.buf == cp || cp[-1] =='\n')1214break;1215}12161217strbuf_addstr(&sb, mine.buf + !!cp);1218exit:1219strbuf_release(&mine);1220 state->msg =strbuf_detach(&sb, &state->msg_len);1221}12221223/**1224 * Parses `mail` using git-mailinfo, extracting its patch and authorship info.1225 * state->msg will be set to the patch message. state->author_name,1226 * state->author_email and state->author_date will be set to the patch author's1227 * name, email and date respectively. The patch body will be written to the1228 * state directory's "patch" file.1229 *1230 * Returns 1 if the patch should be skipped, 0 otherwise.1231 */1232static intparse_mail(struct am_state *state,const char*mail)1233{1234FILE*fp;1235struct strbuf sb = STRBUF_INIT;1236struct strbuf msg = STRBUF_INIT;1237struct strbuf author_name = STRBUF_INIT;1238struct strbuf author_date = STRBUF_INIT;1239struct strbuf author_email = STRBUF_INIT;1240int ret =0;1241struct mailinfo mi;12421243setup_mailinfo(&mi);12441245if(state->utf8)1246 mi.metainfo_charset =get_commit_output_encoding();1247else1248 mi.metainfo_charset = NULL;12491250switch(state->keep) {1251case KEEP_FALSE:1252break;1253case KEEP_TRUE:1254 mi.keep_subject =1;1255break;1256case KEEP_NON_PATCH:1257 mi.keep_non_patch_brackets_in_subject =1;1258break;1259default:1260die("BUG: invalid value for state->keep");1261}12621263if(state->message_id)1264 mi.add_message_id =1;12651266switch(state->scissors) {1267case SCISSORS_UNSET:1268break;1269case SCISSORS_FALSE:1270 mi.use_scissors =0;1271break;1272case SCISSORS_TRUE:1273 mi.use_scissors =1;1274break;1275default:1276die("BUG: invalid value for state->scissors");1277}12781279 mi.input =xfopen(mail,"r");1280 mi.output =xfopen(am_path(state,"info"),"w");1281if(mailinfo(&mi,am_path(state,"msg"),am_path(state,"patch")))1282die("could not parse patch");12831284fclose(mi.input);1285fclose(mi.output);12861287/* Extract message and author information */1288 fp =xfopen(am_path(state,"info"),"r");1289while(!strbuf_getline_lf(&sb, fp)) {1290const char*x;12911292if(skip_prefix(sb.buf,"Subject: ", &x)) {1293if(msg.len)1294strbuf_addch(&msg,'\n');1295strbuf_addstr(&msg, x);1296}else if(skip_prefix(sb.buf,"Author: ", &x))1297strbuf_addstr(&author_name, x);1298else if(skip_prefix(sb.buf,"Email: ", &x))1299strbuf_addstr(&author_email, x);1300else if(skip_prefix(sb.buf,"Date: ", &x))1301strbuf_addstr(&author_date, x);1302}1303fclose(fp);13041305/* Skip pine's internal folder data */1306if(!strcmp(author_name.buf,"Mail System Internal Data")) {1307 ret =1;1308goto finish;1309}13101311if(is_empty_file(am_path(state,"patch"))) {1312printf_ln(_("Patch is empty."));1313die_user_resolve(state);1314}13151316strbuf_addstr(&msg,"\n\n");1317strbuf_addbuf(&msg, &mi.log_message);1318strbuf_stripspace(&msg,0);13191320assert(!state->author_name);1321 state->author_name =strbuf_detach(&author_name, NULL);13221323assert(!state->author_email);1324 state->author_email =strbuf_detach(&author_email, NULL);13251326assert(!state->author_date);1327 state->author_date =strbuf_detach(&author_date, NULL);13281329assert(!state->msg);1330 state->msg =strbuf_detach(&msg, &state->msg_len);13311332finish:1333strbuf_release(&msg);1334strbuf_release(&author_date);1335strbuf_release(&author_email);1336strbuf_release(&author_name);1337strbuf_release(&sb);1338clear_mailinfo(&mi);1339return ret;1340}13411342/**1343 * Sets commit_id to the commit hash where the mail was generated from.1344 * Returns 0 on success, -1 on failure.1345 */1346static intget_mail_commit_oid(struct object_id *commit_id,const char*mail)1347{1348struct strbuf sb = STRBUF_INIT;1349FILE*fp =xfopen(mail,"r");1350const char*x;1351int ret =0;13521353if(strbuf_getline_lf(&sb, fp) ||1354!skip_prefix(sb.buf,"From ", &x) ||1355get_oid_hex(x, commit_id) <0)1356 ret = -1;13571358strbuf_release(&sb);1359fclose(fp);1360return ret;1361}13621363/**1364 * Sets state->msg, state->author_name, state->author_email, state->author_date1365 * to the commit's respective info.1366 */1367static voidget_commit_info(struct am_state *state,struct commit *commit)1368{1369const char*buffer, *ident_line, *msg;1370size_t ident_len;1371struct ident_split id;13721373 buffer =logmsg_reencode(commit, NULL,get_commit_output_encoding());13741375 ident_line =find_commit_header(buffer,"author", &ident_len);13761377if(split_ident_line(&id, ident_line, ident_len) <0)1378die(_("invalid ident line: %.*s"), (int)ident_len, ident_line);13791380assert(!state->author_name);1381if(id.name_begin)1382 state->author_name =1383xmemdupz(id.name_begin, id.name_end - id.name_begin);1384else1385 state->author_name =xstrdup("");13861387assert(!state->author_email);1388if(id.mail_begin)1389 state->author_email =1390xmemdupz(id.mail_begin, id.mail_end - id.mail_begin);1391else1392 state->author_email =xstrdup("");13931394assert(!state->author_date);1395 state->author_date =xstrdup(show_ident_date(&id,DATE_MODE(NORMAL)));13961397assert(!state->msg);1398 msg =strstr(buffer,"\n\n");1399if(!msg)1400die(_("unable to parse commit%s"),oid_to_hex(&commit->object.oid));1401 state->msg =xstrdup(msg +2);1402 state->msg_len =strlen(state->msg);1403unuse_commit_buffer(commit, buffer);1404}14051406/**1407 * Writes `commit` as a patch to the state directory's "patch" file.1408 */1409static voidwrite_commit_patch(const struct am_state *state,struct commit *commit)1410{1411struct rev_info rev_info;1412FILE*fp;14131414 fp =xfopen(am_path(state,"patch"),"w");1415init_revisions(&rev_info, NULL);1416 rev_info.diff =1;1417 rev_info.abbrev =0;1418 rev_info.disable_stdin =1;1419 rev_info.show_root_diff =1;1420 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;1421 rev_info.no_commit_id =1;1422DIFF_OPT_SET(&rev_info.diffopt, BINARY);1423DIFF_OPT_SET(&rev_info.diffopt, FULL_INDEX);1424 rev_info.diffopt.use_color =0;1425 rev_info.diffopt.file = fp;1426 rev_info.diffopt.close_file =1;1427add_pending_object(&rev_info, &commit->object,"");1428diff_setup_done(&rev_info.diffopt);1429log_tree_commit(&rev_info, commit);1430}14311432/**1433 * Writes the diff of the index against HEAD as a patch to the state1434 * directory's "patch" file.1435 */1436static voidwrite_index_patch(const struct am_state *state)1437{1438struct tree *tree;1439struct object_id head;1440struct rev_info rev_info;1441FILE*fp;14421443if(!get_sha1_tree("HEAD", head.hash))1444 tree =lookup_tree(&head);1445else1446 tree =lookup_tree(&empty_tree_oid);14471448 fp =xfopen(am_path(state,"patch"),"w");1449init_revisions(&rev_info, NULL);1450 rev_info.diff =1;1451 rev_info.disable_stdin =1;1452 rev_info.no_commit_id =1;1453 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;1454 rev_info.diffopt.use_color =0;1455 rev_info.diffopt.file = fp;1456 rev_info.diffopt.close_file =1;1457add_pending_object(&rev_info, &tree->object,"");1458diff_setup_done(&rev_info.diffopt);1459run_diff_index(&rev_info,1);1460}14611462/**1463 * Like parse_mail(), but parses the mail by looking up its commit ID1464 * directly. This is used in --rebasing mode to bypass git-mailinfo's munging1465 * of patches.1466 *1467 * state->orig_commit will be set to the original commit ID.1468 *1469 * Will always return 0 as the patch should never be skipped.1470 */1471static intparse_mail_rebase(struct am_state *state,const char*mail)1472{1473struct commit *commit;1474struct object_id commit_oid;14751476if(get_mail_commit_oid(&commit_oid, mail) <0)1477die(_("could not parse%s"), mail);14781479 commit =lookup_commit_or_die(&commit_oid, mail);14801481get_commit_info(state, commit);14821483write_commit_patch(state, commit);14841485oidcpy(&state->orig_commit, &commit_oid);1486write_state_text(state,"original-commit",oid_to_hex(&commit_oid));14871488return0;1489}14901491/**1492 * Applies current patch with git-apply. Returns 0 on success, -1 otherwise. If1493 * `index_file` is not NULL, the patch will be applied to that index.1494 */1495static intrun_apply(const struct am_state *state,const char*index_file)1496{1497struct argv_array apply_paths = ARGV_ARRAY_INIT;1498struct argv_array apply_opts = ARGV_ARRAY_INIT;1499struct apply_state apply_state;1500int res, opts_left;1501static struct lock_file lock_file;1502int force_apply =0;1503int options =0;15041505if(init_apply_state(&apply_state, NULL, &lock_file))1506die("BUG: init_apply_state() failed");15071508argv_array_push(&apply_opts,"apply");1509argv_array_pushv(&apply_opts, state->git_apply_opts.argv);15101511 opts_left =apply_parse_options(apply_opts.argc, apply_opts.argv,1512&apply_state, &force_apply, &options,1513 NULL);15141515if(opts_left !=0)1516die("unknown option passed through to git apply");15171518if(index_file) {1519 apply_state.index_file = index_file;1520 apply_state.cached =1;1521}else1522 apply_state.check_index =1;15231524/*1525 * If we are allowed to fall back on 3-way merge, don't give false1526 * errors during the initial attempt.1527 */1528if(state->threeway && !index_file)1529 apply_state.apply_verbosity = verbosity_silent;15301531if(check_apply_state(&apply_state, force_apply))1532die("BUG: check_apply_state() failed");15331534argv_array_push(&apply_paths,am_path(state,"patch"));15351536 res =apply_all_patches(&apply_state, apply_paths.argc, apply_paths.argv, options);15371538argv_array_clear(&apply_paths);1539argv_array_clear(&apply_opts);1540clear_apply_state(&apply_state);15411542if(res)1543return res;15441545if(index_file) {1546/* Reload index as apply_all_patches() will have modified it. */1547discard_cache();1548read_cache_from(index_file);1549}15501551return0;1552}15531554/**1555 * Builds an index that contains just the blobs needed for a 3way merge.1556 */1557static intbuild_fake_ancestor(const struct am_state *state,const char*index_file)1558{1559struct child_process cp = CHILD_PROCESS_INIT;15601561 cp.git_cmd =1;1562argv_array_push(&cp.args,"apply");1563argv_array_pushv(&cp.args, state->git_apply_opts.argv);1564argv_array_pushf(&cp.args,"--build-fake-ancestor=%s", index_file);1565argv_array_push(&cp.args,am_path(state,"patch"));15661567if(run_command(&cp))1568return-1;15691570return0;1571}15721573/**1574 * Attempt a threeway merge, using index_path as the temporary index.1575 */1576static intfall_back_threeway(const struct am_state *state,const char*index_path)1577{1578struct object_id orig_tree, their_tree, our_tree;1579const struct object_id *bases[1] = { &orig_tree };1580struct merge_options o;1581struct commit *result;1582char*their_tree_name;15831584if(get_oid("HEAD", &our_tree) <0)1585hashcpy(our_tree.hash, EMPTY_TREE_SHA1_BIN);15861587if(build_fake_ancestor(state, index_path))1588returnerror("could not build fake ancestor");15891590discard_cache();1591read_cache_from(index_path);15921593if(write_index_as_tree(orig_tree.hash, &the_index, index_path,0, NULL))1594returnerror(_("Repository lacks necessary blobs to fall back on 3-way merge."));15951596say(state, stdout,_("Using index info to reconstruct a base tree..."));15971598if(!state->quiet) {1599/*1600 * List paths that needed 3-way fallback, so that the user can1601 * review them with extra care to spot mismerges.1602 */1603struct rev_info rev_info;1604const char*diff_filter_str ="--diff-filter=AM";16051606init_revisions(&rev_info, NULL);1607 rev_info.diffopt.output_format = DIFF_FORMAT_NAME_STATUS;1608diff_opt_parse(&rev_info.diffopt, &diff_filter_str,1, rev_info.prefix);1609add_pending_oid(&rev_info,"HEAD", &our_tree,0);1610diff_setup_done(&rev_info.diffopt);1611run_diff_index(&rev_info,1);1612}16131614if(run_apply(state, index_path))1615returnerror(_("Did you hand edit your patch?\n"1616"It does not apply to blobs recorded in its index."));16171618if(write_index_as_tree(their_tree.hash, &the_index, index_path,0, NULL))1619returnerror("could not write tree");16201621say(state, stdout,_("Falling back to patching base and 3-way merge..."));16221623discard_cache();1624read_cache();16251626/*1627 * This is not so wrong. Depending on which base we picked, orig_tree1628 * may be wildly different from ours, but their_tree has the same set of1629 * wildly different changes in parts the patch did not touch, so1630 * recursive ends up canceling them, saying that we reverted all those1631 * changes.1632 */16331634init_merge_options(&o);16351636 o.branch1 ="HEAD";1637 their_tree_name =xstrfmt("%.*s",linelen(state->msg), state->msg);1638 o.branch2 = their_tree_name;16391640if(state->quiet)1641 o.verbosity =0;16421643if(merge_recursive_generic(&o, &our_tree, &their_tree,1, bases, &result)) {1644rerere(state->allow_rerere_autoupdate);1645free(their_tree_name);1646returnerror(_("Failed to merge in the changes."));1647}16481649free(their_tree_name);1650return0;1651}16521653/**1654 * Commits the current index with state->msg as the commit message and1655 * state->author_name, state->author_email and state->author_date as the author1656 * information.1657 */1658static voiddo_commit(const struct am_state *state)1659{1660struct object_id tree, parent, commit;1661const struct object_id *old_oid;1662struct commit_list *parents = NULL;1663const char*reflog_msg, *author;1664struct strbuf sb = STRBUF_INIT;16651666if(run_hook_le(NULL,"pre-applypatch", NULL))1667exit(1);16681669if(write_cache_as_tree(tree.hash,0, NULL))1670die(_("git write-tree failed to write a tree"));16711672if(!get_sha1_commit("HEAD", parent.hash)) {1673 old_oid = &parent;1674commit_list_insert(lookup_commit(&parent), &parents);1675}else{1676 old_oid = NULL;1677say(state, stderr,_("applying to an empty history"));1678}16791680 author =fmt_ident(state->author_name, state->author_email,1681 state->ignore_date ? NULL : state->author_date,1682 IDENT_STRICT);16831684if(state->committer_date_is_author_date)1685setenv("GIT_COMMITTER_DATE",1686 state->ignore_date ?"": state->author_date,1);16871688if(commit_tree(state->msg, state->msg_len, tree.hash, parents, commit.hash,1689 author, state->sign_commit))1690die(_("failed to write commit object"));16911692 reflog_msg =getenv("GIT_REFLOG_ACTION");1693if(!reflog_msg)1694 reflog_msg ="am";16951696strbuf_addf(&sb,"%s: %.*s", reflog_msg,linelen(state->msg),1697 state->msg);16981699update_ref_oid(sb.buf,"HEAD", &commit, old_oid,0,1700 UPDATE_REFS_DIE_ON_ERR);17011702if(state->rebasing) {1703FILE*fp =xfopen(am_path(state,"rewritten"),"a");17041705assert(!is_null_oid(&state->orig_commit));1706fprintf(fp,"%s",oid_to_hex(&state->orig_commit));1707fprintf(fp,"%s\n",oid_to_hex(&commit));1708fclose(fp);1709}17101711run_hook_le(NULL,"post-applypatch", NULL);17121713strbuf_release(&sb);1714}17151716/**1717 * Validates the am_state for resuming -- the "msg" and authorship fields must1718 * be filled up.1719 */1720static voidvalidate_resume_state(const struct am_state *state)1721{1722if(!state->msg)1723die(_("cannot resume:%sdoes not exist."),1724am_path(state,"final-commit"));17251726if(!state->author_name || !state->author_email || !state->author_date)1727die(_("cannot resume:%sdoes not exist."),1728am_path(state,"author-script"));1729}17301731/**1732 * Interactively prompt the user on whether the current patch should be1733 * applied.1734 *1735 * Returns 0 if the user chooses to apply the patch, 1 if the user chooses to1736 * skip it.1737 */1738static intdo_interactive(struct am_state *state)1739{1740assert(state->msg);17411742if(!isatty(0))1743die(_("cannot be interactive without stdin connected to a terminal."));17441745for(;;) {1746const char*reply;17471748puts(_("Commit Body is:"));1749puts("--------------------------");1750printf("%s", state->msg);1751puts("--------------------------");17521753/*1754 * TRANSLATORS: Make sure to include [y], [n], [e], [v] and [a]1755 * in your translation. The program will only accept English1756 * input at this point.1757 */1758 reply =git_prompt(_("Apply? [y]es/[n]o/[e]dit/[v]iew patch/[a]ccept all: "), PROMPT_ECHO);17591760if(!reply) {1761continue;1762}else if(*reply =='y'|| *reply =='Y') {1763return0;1764}else if(*reply =='a'|| *reply =='A') {1765 state->interactive =0;1766return0;1767}else if(*reply =='n'|| *reply =='N') {1768return1;1769}else if(*reply =='e'|| *reply =='E') {1770struct strbuf msg = STRBUF_INIT;17711772if(!launch_editor(am_path(state,"final-commit"), &msg, NULL)) {1773free(state->msg);1774 state->msg =strbuf_detach(&msg, &state->msg_len);1775}1776strbuf_release(&msg);1777}else if(*reply =='v'|| *reply =='V') {1778const char*pager =git_pager(1);1779struct child_process cp = CHILD_PROCESS_INIT;17801781if(!pager)1782 pager ="cat";1783prepare_pager_args(&cp, pager);1784argv_array_push(&cp.args,am_path(state,"patch"));1785run_command(&cp);1786}1787}1788}17891790/**1791 * Applies all queued mail.1792 *1793 * If `resume` is true, we are "resuming". The "msg" and authorship fields, as1794 * well as the state directory's "patch" file is used as-is for applying the1795 * patch and committing it.1796 */1797static voidam_run(struct am_state *state,int resume)1798{1799const char*argv_gc_auto[] = {"gc","--auto", NULL};1800struct strbuf sb = STRBUF_INIT;18011802unlink(am_path(state,"dirtyindex"));18031804refresh_and_write_cache();18051806if(index_has_changes(&sb)) {1807write_state_bool(state,"dirtyindex",1);1808die(_("Dirty index: cannot apply patches (dirty:%s)"), sb.buf);1809}18101811strbuf_release(&sb);18121813while(state->cur <= state->last) {1814const char*mail =am_path(state,msgnum(state));1815int apply_status;18161817reset_ident_date();18181819if(!file_exists(mail))1820goto next;18211822if(resume) {1823validate_resume_state(state);1824}else{1825int skip;18261827if(state->rebasing)1828 skip =parse_mail_rebase(state, mail);1829else1830 skip =parse_mail(state, mail);18311832if(skip)1833goto next;/* mail should be skipped */18341835if(state->signoff)1836am_append_signoff(state);18371838write_author_script(state);1839write_commit_msg(state);1840}18411842if(state->interactive &&do_interactive(state))1843goto next;18441845if(run_applypatch_msg_hook(state))1846exit(1);18471848say(state, stdout,_("Applying: %.*s"),linelen(state->msg), state->msg);18491850 apply_status =run_apply(state, NULL);18511852if(apply_status && state->threeway) {1853struct strbuf sb = STRBUF_INIT;18541855strbuf_addstr(&sb,am_path(state,"patch-merge-index"));1856 apply_status =fall_back_threeway(state, sb.buf);1857strbuf_release(&sb);18581859/*1860 * Applying the patch to an earlier tree and merging1861 * the result may have produced the same tree as ours.1862 */1863if(!apply_status && !index_has_changes(NULL)) {1864say(state, stdout,_("No changes -- Patch already applied."));1865goto next;1866}1867}18681869if(apply_status) {1870int advice_amworkdir =1;18711872printf_ln(_("Patch failed at%s%.*s"),msgnum(state),1873linelen(state->msg), state->msg);18741875git_config_get_bool("advice.amworkdir", &advice_amworkdir);18761877if(advice_amworkdir)1878printf_ln(_("The copy of the patch that failed is found in:%s"),1879am_path(state,"patch"));18801881die_user_resolve(state);1882}18831884do_commit(state);18851886next:1887am_next(state);18881889if(resume)1890am_load(state);1891 resume =0;1892}18931894if(!is_empty_file(am_path(state,"rewritten"))) {1895assert(state->rebasing);1896copy_notes_for_rebase(state);1897run_post_rewrite_hook(state);1898}18991900/*1901 * In rebasing mode, it's up to the caller to take care of1902 * housekeeping.1903 */1904if(!state->rebasing) {1905am_destroy(state);1906close_all_packs();1907run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);1908}1909}19101911/**1912 * Resume the current am session after patch application failure. The user did1913 * all the hard work, and we do not have to do any patch application. Just1914 * trust and commit what the user has in the index and working tree.1915 */1916static voidam_resolve(struct am_state *state)1917{1918validate_resume_state(state);19191920say(state, stdout,_("Applying: %.*s"),linelen(state->msg), state->msg);19211922if(!index_has_changes(NULL)) {1923printf_ln(_("No changes - did you forget to use 'git add'?\n"1924"If there is nothing left to stage, chances are that something else\n"1925"already introduced the same changes; you might want to skip this patch."));1926die_user_resolve(state);1927}19281929if(unmerged_cache()) {1930printf_ln(_("You still have unmerged paths in your index.\n"1931"You should 'git add' each file with resolved conflicts to mark them as such.\n"1932"You might run `git rm` on a file to accept\"deleted by them\"for it."));1933die_user_resolve(state);1934}19351936if(state->interactive) {1937write_index_patch(state);1938if(do_interactive(state))1939goto next;1940}19411942rerere(0);19431944do_commit(state);19451946next:1947am_next(state);1948am_load(state);1949am_run(state,0);1950}19511952/**1953 * Performs a checkout fast-forward from `head` to `remote`. If `reset` is1954 * true, any unmerged entries will be discarded. Returns 0 on success, -1 on1955 * failure.1956 */1957static intfast_forward_to(struct tree *head,struct tree *remote,int reset)1958{1959struct lock_file *lock_file;1960struct unpack_trees_options opts;1961struct tree_desc t[2];19621963if(parse_tree(head) ||parse_tree(remote))1964return-1;19651966 lock_file =xcalloc(1,sizeof(struct lock_file));1967hold_locked_index(lock_file, LOCK_DIE_ON_ERROR);19681969refresh_cache(REFRESH_QUIET);19701971memset(&opts,0,sizeof(opts));1972 opts.head_idx =1;1973 opts.src_index = &the_index;1974 opts.dst_index = &the_index;1975 opts.update =1;1976 opts.merge =1;1977 opts.reset = reset;1978 opts.fn = twoway_merge;1979init_tree_desc(&t[0], head->buffer, head->size);1980init_tree_desc(&t[1], remote->buffer, remote->size);19811982if(unpack_trees(2, t, &opts)) {1983rollback_lock_file(lock_file);1984return-1;1985}19861987if(write_locked_index(&the_index, lock_file, COMMIT_LOCK))1988die(_("unable to write new index file"));19891990return0;1991}19921993/**1994 * Merges a tree into the index. The index's stat info will take precedence1995 * over the merged tree's. Returns 0 on success, -1 on failure.1996 */1997static intmerge_tree(struct tree *tree)1998{1999struct lock_file *lock_file;2000struct unpack_trees_options opts;2001struct tree_desc t[1];20022003if(parse_tree(tree))2004return-1;20052006 lock_file =xcalloc(1,sizeof(struct lock_file));2007hold_locked_index(lock_file, LOCK_DIE_ON_ERROR);20082009memset(&opts,0,sizeof(opts));2010 opts.head_idx =1;2011 opts.src_index = &the_index;2012 opts.dst_index = &the_index;2013 opts.merge =1;2014 opts.fn = oneway_merge;2015init_tree_desc(&t[0], tree->buffer, tree->size);20162017if(unpack_trees(1, t, &opts)) {2018rollback_lock_file(lock_file);2019return-1;2020}20212022if(write_locked_index(&the_index, lock_file, COMMIT_LOCK))2023die(_("unable to write new index file"));20242025return0;2026}20272028/**2029 * Clean the index without touching entries that are not modified between2030 * `head` and `remote`.2031 */2032static intclean_index(const struct object_id *head,const struct object_id *remote)2033{2034struct tree *head_tree, *remote_tree, *index_tree;2035struct object_id index;20362037 head_tree =parse_tree_indirect(head);2038if(!head_tree)2039returnerror(_("Could not parse object '%s'."),oid_to_hex(head));20402041 remote_tree =parse_tree_indirect(remote);2042if(!remote_tree)2043returnerror(_("Could not parse object '%s'."),oid_to_hex(remote));20442045read_cache_unmerged();20462047if(fast_forward_to(head_tree, head_tree,1))2048return-1;20492050if(write_cache_as_tree(index.hash,0, NULL))2051return-1;20522053 index_tree =parse_tree_indirect(&index);2054if(!index_tree)2055returnerror(_("Could not parse object '%s'."),oid_to_hex(&index));20562057if(fast_forward_to(index_tree, remote_tree,0))2058return-1;20592060if(merge_tree(remote_tree))2061return-1;20622063remove_branch_state();20642065return0;2066}20672068/**2069 * Resets rerere's merge resolution metadata.2070 */2071static voidam_rerere_clear(void)2072{2073struct string_list merge_rr = STRING_LIST_INIT_DUP;2074rerere_clear(&merge_rr);2075string_list_clear(&merge_rr,1);2076}20772078/**2079 * Resume the current am session by skipping the current patch.2080 */2081static voidam_skip(struct am_state *state)2082{2083struct object_id head;20842085am_rerere_clear();20862087if(get_oid("HEAD", &head))2088hashcpy(head.hash, EMPTY_TREE_SHA1_BIN);20892090if(clean_index(&head, &head))2091die(_("failed to clean index"));20922093am_next(state);2094am_load(state);2095am_run(state,0);2096}20972098/**2099 * Returns true if it is safe to reset HEAD to the ORIG_HEAD, false otherwise.2100 *2101 * It is not safe to reset HEAD when:2102 * 1. git-am previously failed because the index was dirty.2103 * 2. HEAD has moved since git-am previously failed.2104 */2105static intsafe_to_abort(const struct am_state *state)2106{2107struct strbuf sb = STRBUF_INIT;2108struct object_id abort_safety, head;21092110if(file_exists(am_path(state,"dirtyindex")))2111return0;21122113if(read_state_file(&sb, state,"abort-safety",1) >0) {2114if(get_oid_hex(sb.buf, &abort_safety))2115die(_("could not parse%s"),am_path(state,"abort-safety"));2116}else2117oidclr(&abort_safety);21182119if(get_oid("HEAD", &head))2120oidclr(&head);21212122if(!oidcmp(&head, &abort_safety))2123return1;21242125warning(_("You seem to have moved HEAD since the last 'am' failure.\n"2126"Not rewinding to ORIG_HEAD"));21272128return0;2129}21302131/**2132 * Aborts the current am session if it is safe to do so.2133 */2134static voidam_abort(struct am_state *state)2135{2136struct object_id curr_head, orig_head;2137int has_curr_head, has_orig_head;2138char*curr_branch;21392140if(!safe_to_abort(state)) {2141am_destroy(state);2142return;2143}21442145am_rerere_clear();21462147 curr_branch =resolve_refdup("HEAD",0, curr_head.hash, NULL);2148 has_curr_head = curr_branch && !is_null_oid(&curr_head);2149if(!has_curr_head)2150hashcpy(curr_head.hash, EMPTY_TREE_SHA1_BIN);21512152 has_orig_head = !get_oid("ORIG_HEAD", &orig_head);2153if(!has_orig_head)2154hashcpy(orig_head.hash, EMPTY_TREE_SHA1_BIN);21552156clean_index(&curr_head, &orig_head);21572158if(has_orig_head)2159update_ref_oid("am --abort","HEAD", &orig_head,2160 has_curr_head ? &curr_head : NULL,0,2161 UPDATE_REFS_DIE_ON_ERR);2162else if(curr_branch)2163delete_ref(NULL, curr_branch, NULL, REF_NODEREF);21642165free(curr_branch);2166am_destroy(state);2167}21682169/**2170 * parse_options() callback that validates and sets opt->value to the2171 * PATCH_FORMAT_* enum value corresponding to `arg`.2172 */2173static intparse_opt_patchformat(const struct option *opt,const char*arg,int unset)2174{2175int*opt_value = opt->value;21762177if(!strcmp(arg,"mbox"))2178*opt_value = PATCH_FORMAT_MBOX;2179else if(!strcmp(arg,"stgit"))2180*opt_value = PATCH_FORMAT_STGIT;2181else if(!strcmp(arg,"stgit-series"))2182*opt_value = PATCH_FORMAT_STGIT_SERIES;2183else if(!strcmp(arg,"hg"))2184*opt_value = PATCH_FORMAT_HG;2185else if(!strcmp(arg,"mboxrd"))2186*opt_value = PATCH_FORMAT_MBOXRD;2187else2188returnerror(_("Invalid value for --patch-format:%s"), arg);2189return0;2190}21912192enum resume_mode {2193 RESUME_FALSE =0,2194 RESUME_APPLY,2195 RESUME_RESOLVED,2196 RESUME_SKIP,2197 RESUME_ABORT2198};21992200static intgit_am_config(const char*k,const char*v,void*cb)2201{2202int status;22032204 status =git_gpg_config(k, v, NULL);2205if(status)2206return status;22072208returngit_default_config(k, v, NULL);2209}22102211intcmd_am(int argc,const char**argv,const char*prefix)2212{2213struct am_state state;2214int binary = -1;2215int keep_cr = -1;2216int patch_format = PATCH_FORMAT_UNKNOWN;2217enum resume_mode resume = RESUME_FALSE;2218int in_progress;22192220const char*const usage[] = {2221N_("git am [<options>] [(<mbox> | <Maildir>)...]"),2222N_("git am [<options>] (--continue | --skip | --abort)"),2223 NULL2224};22252226struct option options[] = {2227OPT_BOOL('i',"interactive", &state.interactive,2228N_("run interactively")),2229OPT_HIDDEN_BOOL('b',"binary", &binary,2230N_("historical option -- no-op")),2231OPT_BOOL('3',"3way", &state.threeway,2232N_("allow fall back on 3way merging if needed")),2233OPT__QUIET(&state.quiet,N_("be quiet")),2234OPT_SET_INT('s',"signoff", &state.signoff,2235N_("add a Signed-off-by line to the commit message"),2236 SIGNOFF_EXPLICIT),2237OPT_BOOL('u',"utf8", &state.utf8,2238N_("recode into utf8 (default)")),2239OPT_SET_INT('k',"keep", &state.keep,2240N_("pass -k flag to git-mailinfo"), KEEP_TRUE),2241OPT_SET_INT(0,"keep-non-patch", &state.keep,2242N_("pass -b flag to git-mailinfo"), KEEP_NON_PATCH),2243OPT_BOOL('m',"message-id", &state.message_id,2244N_("pass -m flag to git-mailinfo")),2245{ OPTION_SET_INT,0,"keep-cr", &keep_cr, NULL,2246N_("pass --keep-cr flag to git-mailsplit for mbox format"),2247 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},2248{ OPTION_SET_INT,0,"no-keep-cr", &keep_cr, NULL,2249N_("do not pass --keep-cr flag to git-mailsplit independent of am.keepcr"),2250 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,0},2251OPT_BOOL('c',"scissors", &state.scissors,2252N_("strip everything before a scissors line")),2253OPT_PASSTHRU_ARGV(0,"whitespace", &state.git_apply_opts,N_("action"),2254N_("pass it through git-apply"),22550),2256OPT_PASSTHRU_ARGV(0,"ignore-space-change", &state.git_apply_opts, NULL,2257N_("pass it through git-apply"),2258 PARSE_OPT_NOARG),2259OPT_PASSTHRU_ARGV(0,"ignore-whitespace", &state.git_apply_opts, NULL,2260N_("pass it through git-apply"),2261 PARSE_OPT_NOARG),2262OPT_PASSTHRU_ARGV(0,"directory", &state.git_apply_opts,N_("root"),2263N_("pass it through git-apply"),22640),2265OPT_PASSTHRU_ARGV(0,"exclude", &state.git_apply_opts,N_("path"),2266N_("pass it through git-apply"),22670),2268OPT_PASSTHRU_ARGV(0,"include", &state.git_apply_opts,N_("path"),2269N_("pass it through git-apply"),22700),2271OPT_PASSTHRU_ARGV('C', NULL, &state.git_apply_opts,N_("n"),2272N_("pass it through git-apply"),22730),2274OPT_PASSTHRU_ARGV('p', NULL, &state.git_apply_opts,N_("num"),2275N_("pass it through git-apply"),22760),2277OPT_CALLBACK(0,"patch-format", &patch_format,N_("format"),2278N_("format the patch(es) are in"),2279 parse_opt_patchformat),2280OPT_PASSTHRU_ARGV(0,"reject", &state.git_apply_opts, NULL,2281N_("pass it through git-apply"),2282 PARSE_OPT_NOARG),2283OPT_STRING(0,"resolvemsg", &state.resolvemsg, NULL,2284N_("override error message when patch failure occurs")),2285OPT_CMDMODE(0,"continue", &resume,2286N_("continue applying patches after resolving a conflict"),2287 RESUME_RESOLVED),2288OPT_CMDMODE('r',"resolved", &resume,2289N_("synonyms for --continue"),2290 RESUME_RESOLVED),2291OPT_CMDMODE(0,"skip", &resume,2292N_("skip the current patch"),2293 RESUME_SKIP),2294OPT_CMDMODE(0,"abort", &resume,2295N_("restore the original branch and abort the patching operation."),2296 RESUME_ABORT),2297OPT_BOOL(0,"committer-date-is-author-date",2298&state.committer_date_is_author_date,2299N_("lie about committer date")),2300OPT_BOOL(0,"ignore-date", &state.ignore_date,2301N_("use current timestamp for author date")),2302OPT_RERERE_AUTOUPDATE(&state.allow_rerere_autoupdate),2303{ OPTION_STRING,'S',"gpg-sign", &state.sign_commit,N_("key-id"),2304N_("GPG-sign commits"),2305 PARSE_OPT_OPTARG, NULL, (intptr_t)""},2306OPT_HIDDEN_BOOL(0,"rebasing", &state.rebasing,2307N_("(internal use for git-rebase)")),2308OPT_END()2309};23102311if(argc ==2&& !strcmp(argv[1],"-h"))2312usage_with_options(usage, options);23132314git_config(git_am_config, NULL);23152316am_state_init(&state);23172318 in_progress =am_in_progress(&state);2319if(in_progress)2320am_load(&state);23212322 argc =parse_options(argc, argv, prefix, options, usage,0);23232324if(binary >=0)2325fprintf_ln(stderr,_("The -b/--binary option has been a no-op for long time, and\n"2326"it will be removed. Please do not use it anymore."));23272328/* Ensure a valid committer ident can be constructed */2329git_committer_info(IDENT_STRICT);23302331if(read_index_preload(&the_index, NULL) <0)2332die(_("failed to read the index"));23332334if(in_progress) {2335/*2336 * Catch user error to feed us patches when there is a session2337 * in progress:2338 *2339 * 1. mbox path(s) are provided on the command-line.2340 * 2. stdin is not a tty: the user is trying to feed us a patch2341 * from standard input. This is somewhat unreliable -- stdin2342 * could be /dev/null for example and the caller did not2343 * intend to feed us a patch but wanted to continue2344 * unattended.2345 */2346if(argc || (resume == RESUME_FALSE && !isatty(0)))2347die(_("previous rebase directory%sstill exists but mbox given."),2348 state.dir);23492350if(resume == RESUME_FALSE)2351 resume = RESUME_APPLY;23522353if(state.signoff == SIGNOFF_EXPLICIT)2354am_append_signoff(&state);2355}else{2356struct argv_array paths = ARGV_ARRAY_INIT;2357int i;23582359/*2360 * Handle stray state directory in the independent-run case. In2361 * the --rebasing case, it is up to the caller to take care of2362 * stray directories.2363 */2364if(file_exists(state.dir) && !state.rebasing) {2365if(resume == RESUME_ABORT) {2366am_destroy(&state);2367am_state_release(&state);2368return0;2369}23702371die(_("Stray%sdirectory found.\n"2372"Use\"git am --abort\"to remove it."),2373 state.dir);2374}23752376if(resume)2377die(_("Resolve operation not in progress, we are not resuming."));23782379for(i =0; i < argc; i++) {2380if(is_absolute_path(argv[i]) || !prefix)2381argv_array_push(&paths, argv[i]);2382else2383argv_array_push(&paths,mkpath("%s/%s", prefix, argv[i]));2384}23852386am_setup(&state, patch_format, paths.argv, keep_cr);23872388argv_array_clear(&paths);2389}23902391switch(resume) {2392case RESUME_FALSE:2393am_run(&state,0);2394break;2395case RESUME_APPLY:2396am_run(&state,1);2397break;2398case RESUME_RESOLVED:2399am_resolve(&state);2400break;2401case RESUME_SKIP:2402am_skip(&state);2403break;2404case RESUME_ABORT:2405am_abort(&state);2406break;2407default:2408die("BUG: invalid resume value");2409}24102411am_state_release(&state);24122413return0;2414}