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 36/** 37 * Returns 1 if the file is empty or does not exist, 0 otherwise. 38 */ 39static intis_empty_file(const char*filename) 40{ 41struct stat st; 42 43if(stat(filename, &st) <0) { 44if(errno == ENOENT) 45return1; 46die_errno(_("could not stat%s"), filename); 47} 48 49return!st.st_size; 50} 51 52/** 53 * Returns the length of the first line of msg. 54 */ 55static intlinelen(const char*msg) 56{ 57returnstrchrnul(msg,'\n') - msg; 58} 59 60/** 61 * Returns true if `str` consists of only whitespace, false otherwise. 62 */ 63static intstr_isspace(const char*str) 64{ 65for(; *str; str++) 66if(!isspace(*str)) 67return0; 68 69return1; 70} 71 72enum patch_format { 73 PATCH_FORMAT_UNKNOWN =0, 74 PATCH_FORMAT_MBOX, 75 PATCH_FORMAT_STGIT, 76 PATCH_FORMAT_STGIT_SERIES, 77 PATCH_FORMAT_HG, 78 PATCH_FORMAT_MBOXRD 79}; 80 81enum keep_type { 82 KEEP_FALSE =0, 83 KEEP_TRUE,/* pass -k flag to git-mailinfo */ 84 KEEP_NON_PATCH /* pass -b flag to git-mailinfo */ 85}; 86 87enum scissors_type { 88 SCISSORS_UNSET = -1, 89 SCISSORS_FALSE =0,/* pass --no-scissors to git-mailinfo */ 90 SCISSORS_TRUE /* pass --scissors to git-mailinfo */ 91}; 92 93enum signoff_type { 94 SIGNOFF_FALSE =0, 95 SIGNOFF_TRUE =1, 96 SIGNOFF_EXPLICIT /* --signoff was set on the command-line */ 97}; 98 99struct am_state { 100/* state directory path */ 101char*dir; 102 103/* current and last patch numbers, 1-indexed */ 104int cur; 105int last; 106 107/* commit metadata and message */ 108char*author_name; 109char*author_email; 110char*author_date; 111char*msg; 112size_t msg_len; 113 114/* when --rebasing, records the original commit the patch came from */ 115struct object_id orig_commit; 116 117/* number of digits in patch filename */ 118int prec; 119 120/* various operating modes and command line options */ 121int interactive; 122int threeway; 123int quiet; 124int signoff;/* enum signoff_type */ 125int utf8; 126int keep;/* enum keep_type */ 127int message_id; 128int scissors;/* enum scissors_type */ 129struct argv_array git_apply_opts; 130const char*resolvemsg; 131int committer_date_is_author_date; 132int ignore_date; 133int allow_rerere_autoupdate; 134const char*sign_commit; 135int rebasing; 136}; 137 138/** 139 * Initializes am_state with the default values. 140 */ 141static voidam_state_init(struct am_state *state) 142{ 143int gpgsign; 144 145memset(state,0,sizeof(*state)); 146 147 state->dir =git_pathdup("rebase-apply"); 148 149 state->prec =4; 150 151git_config_get_bool("am.threeway", &state->threeway); 152 153 state->utf8 =1; 154 155git_config_get_bool("am.messageid", &state->message_id); 156 157 state->scissors = SCISSORS_UNSET; 158 159argv_array_init(&state->git_apply_opts); 160 161if(!git_config_get_bool("commit.gpgsign", &gpgsign)) 162 state->sign_commit = gpgsign ?"": NULL; 163} 164 165/** 166 * Releases memory allocated by an am_state. 167 */ 168static voidam_state_release(struct am_state *state) 169{ 170free(state->dir); 171free(state->author_name); 172free(state->author_email); 173free(state->author_date); 174free(state->msg); 175argv_array_clear(&state->git_apply_opts); 176} 177 178/** 179 * Returns path relative to the am_state directory. 180 */ 181staticinlineconst char*am_path(const struct am_state *state,const char*path) 182{ 183returnmkpath("%s/%s", state->dir, path); 184} 185 186/** 187 * For convenience to call write_file() 188 */ 189static voidwrite_state_text(const struct am_state *state, 190const char*name,const char*string) 191{ 192write_file(am_path(state, name),"%s", string); 193} 194 195static voidwrite_state_count(const struct am_state *state, 196const char*name,int value) 197{ 198write_file(am_path(state, name),"%d", value); 199} 200 201static voidwrite_state_bool(const struct am_state *state, 202const char*name,int value) 203{ 204write_state_text(state, name, value ?"t":"f"); 205} 206 207/** 208 * If state->quiet is false, calls fprintf(fp, fmt, ...), and appends a newline 209 * at the end. 210 */ 211static voidsay(const struct am_state *state,FILE*fp,const char*fmt, ...) 212{ 213va_list ap; 214 215va_start(ap, fmt); 216if(!state->quiet) { 217vfprintf(fp, fmt, ap); 218putc('\n', fp); 219} 220va_end(ap); 221} 222 223/** 224 * Returns 1 if there is an am session in progress, 0 otherwise. 225 */ 226static intam_in_progress(const struct am_state *state) 227{ 228struct stat st; 229 230if(lstat(state->dir, &st) <0|| !S_ISDIR(st.st_mode)) 231return0; 232if(lstat(am_path(state,"last"), &st) || !S_ISREG(st.st_mode)) 233return0; 234if(lstat(am_path(state,"next"), &st) || !S_ISREG(st.st_mode)) 235return0; 236return1; 237} 238 239/** 240 * Reads the contents of `file` in the `state` directory into `sb`. Returns the 241 * number of bytes read on success, -1 if the file does not exist. If `trim` is 242 * set, trailing whitespace will be removed. 243 */ 244static intread_state_file(struct strbuf *sb,const struct am_state *state, 245const char*file,int trim) 246{ 247strbuf_reset(sb); 248 249if(strbuf_read_file(sb,am_path(state, file),0) >=0) { 250if(trim) 251strbuf_trim(sb); 252 253return sb->len; 254} 255 256if(errno == ENOENT) 257return-1; 258 259die_errno(_("could not read '%s'"),am_path(state, file)); 260} 261 262/** 263 * Take a series of KEY='VALUE' lines where VALUE part is 264 * sq-quoted, and append <KEY, VALUE> at the end of the string list 265 */ 266static intparse_key_value_squoted(char*buf,struct string_list *list) 267{ 268while(*buf) { 269struct string_list_item *item; 270char*np; 271char*cp =strchr(buf,'='); 272if(!cp) 273return-1; 274 np =strchrnul(cp,'\n'); 275*cp++ ='\0'; 276 item =string_list_append(list, buf); 277 278 buf = np + (*np =='\n'); 279*np ='\0'; 280 cp =sq_dequote(cp); 281if(!cp) 282return-1; 283 item->util =xstrdup(cp); 284} 285return0; 286} 287 288/** 289 * Reads and parses the state directory's "author-script" file, and sets 290 * state->author_name, state->author_email and state->author_date accordingly. 291 * Returns 0 on success, -1 if the file could not be parsed. 292 * 293 * The author script is of the format: 294 * 295 * GIT_AUTHOR_NAME='$author_name' 296 * GIT_AUTHOR_EMAIL='$author_email' 297 * GIT_AUTHOR_DATE='$author_date' 298 * 299 * where $author_name, $author_email and $author_date are quoted. We are strict 300 * with our parsing, as the file was meant to be eval'd in the old git-am.sh 301 * script, and thus if the file differs from what this function expects, it is 302 * better to bail out than to do something that the user does not expect. 303 */ 304static intread_author_script(struct am_state *state) 305{ 306const char*filename =am_path(state,"author-script"); 307struct strbuf buf = STRBUF_INIT; 308struct string_list kv = STRING_LIST_INIT_DUP; 309int retval = -1;/* assume failure */ 310int fd; 311 312assert(!state->author_name); 313assert(!state->author_email); 314assert(!state->author_date); 315 316 fd =open(filename, O_RDONLY); 317if(fd <0) { 318if(errno == ENOENT) 319return0; 320die_errno(_("could not open '%s' for reading"), filename); 321} 322strbuf_read(&buf, fd,0); 323close(fd); 324if(parse_key_value_squoted(buf.buf, &kv)) 325goto finish; 326 327if(kv.nr !=3|| 328strcmp(kv.items[0].string,"GIT_AUTHOR_NAME") || 329strcmp(kv.items[1].string,"GIT_AUTHOR_EMAIL") || 330strcmp(kv.items[2].string,"GIT_AUTHOR_DATE")) 331goto finish; 332 state->author_name = kv.items[0].util; 333 state->author_email = kv.items[1].util; 334 state->author_date = kv.items[2].util; 335 retval =0; 336finish: 337string_list_clear(&kv, !!retval); 338strbuf_release(&buf); 339return retval; 340} 341 342/** 343 * Saves state->author_name, state->author_email and state->author_date in the 344 * state directory's "author-script" file. 345 */ 346static voidwrite_author_script(const struct am_state *state) 347{ 348struct strbuf sb = STRBUF_INIT; 349 350strbuf_addstr(&sb,"GIT_AUTHOR_NAME="); 351sq_quote_buf(&sb, state->author_name); 352strbuf_addch(&sb,'\n'); 353 354strbuf_addstr(&sb,"GIT_AUTHOR_EMAIL="); 355sq_quote_buf(&sb, state->author_email); 356strbuf_addch(&sb,'\n'); 357 358strbuf_addstr(&sb,"GIT_AUTHOR_DATE="); 359sq_quote_buf(&sb, state->author_date); 360strbuf_addch(&sb,'\n'); 361 362write_state_text(state,"author-script", sb.buf); 363 364strbuf_release(&sb); 365} 366 367/** 368 * Reads the commit message from the state directory's "final-commit" file, 369 * setting state->msg to its contents and state->msg_len to the length of its 370 * contents in bytes. 371 * 372 * Returns 0 on success, -1 if the file does not exist. 373 */ 374static intread_commit_msg(struct am_state *state) 375{ 376struct strbuf sb = STRBUF_INIT; 377 378assert(!state->msg); 379 380if(read_state_file(&sb, state,"final-commit",0) <0) { 381strbuf_release(&sb); 382return-1; 383} 384 385 state->msg =strbuf_detach(&sb, &state->msg_len); 386return0; 387} 388 389/** 390 * Saves state->msg in the state directory's "final-commit" file. 391 */ 392static voidwrite_commit_msg(const struct am_state *state) 393{ 394const char*filename =am_path(state,"final-commit"); 395write_file_buf(filename, state->msg, state->msg_len); 396} 397 398/** 399 * Loads state from disk. 400 */ 401static voidam_load(struct am_state *state) 402{ 403struct strbuf sb = STRBUF_INIT; 404 405if(read_state_file(&sb, state,"next",1) <0) 406die("BUG: state file 'next' does not exist"); 407 state->cur =strtol(sb.buf, NULL,10); 408 409if(read_state_file(&sb, state,"last",1) <0) 410die("BUG: state file 'last' does not exist"); 411 state->last =strtol(sb.buf, NULL,10); 412 413if(read_author_script(state) <0) 414die(_("could not parse author script")); 415 416read_commit_msg(state); 417 418if(read_state_file(&sb, state,"original-commit",1) <0) 419oidclr(&state->orig_commit); 420else if(get_oid_hex(sb.buf, &state->orig_commit) <0) 421die(_("could not parse%s"),am_path(state,"original-commit")); 422 423read_state_file(&sb, state,"threeway",1); 424 state->threeway = !strcmp(sb.buf,"t"); 425 426read_state_file(&sb, state,"quiet",1); 427 state->quiet = !strcmp(sb.buf,"t"); 428 429read_state_file(&sb, state,"sign",1); 430 state->signoff = !strcmp(sb.buf,"t"); 431 432read_state_file(&sb, state,"utf8",1); 433 state->utf8 = !strcmp(sb.buf,"t"); 434 435if(file_exists(am_path(state,"rerere-autoupdate"))) { 436read_state_file(&sb, state,"rerere-autoupdate",1); 437 state->allow_rerere_autoupdate =strcmp(sb.buf,"t") ? 438 RERERE_NOAUTOUPDATE : RERERE_AUTOUPDATE; 439}else{ 440 state->allow_rerere_autoupdate =0; 441} 442 443read_state_file(&sb, state,"keep",1); 444if(!strcmp(sb.buf,"t")) 445 state->keep = KEEP_TRUE; 446else if(!strcmp(sb.buf,"b")) 447 state->keep = KEEP_NON_PATCH; 448else 449 state->keep = KEEP_FALSE; 450 451read_state_file(&sb, state,"messageid",1); 452 state->message_id = !strcmp(sb.buf,"t"); 453 454read_state_file(&sb, state,"scissors",1); 455if(!strcmp(sb.buf,"t")) 456 state->scissors = SCISSORS_TRUE; 457else if(!strcmp(sb.buf,"f")) 458 state->scissors = SCISSORS_FALSE; 459else 460 state->scissors = SCISSORS_UNSET; 461 462read_state_file(&sb, state,"apply-opt",1); 463argv_array_clear(&state->git_apply_opts); 464if(sq_dequote_to_argv_array(sb.buf, &state->git_apply_opts) <0) 465die(_("could not parse%s"),am_path(state,"apply-opt")); 466 467 state->rebasing = !!file_exists(am_path(state,"rebasing")); 468 469strbuf_release(&sb); 470} 471 472/** 473 * Removes the am_state directory, forcefully terminating the current am 474 * session. 475 */ 476static voidam_destroy(const struct am_state *state) 477{ 478struct strbuf sb = STRBUF_INIT; 479 480strbuf_addstr(&sb, state->dir); 481remove_dir_recursively(&sb,0); 482strbuf_release(&sb); 483} 484 485/** 486 * Runs applypatch-msg hook. Returns its exit code. 487 */ 488static intrun_applypatch_msg_hook(struct am_state *state) 489{ 490int ret; 491 492assert(state->msg); 493 ret =run_hook_le(NULL,"applypatch-msg",am_path(state,"final-commit"), NULL); 494 495if(!ret) { 496FREE_AND_NULL(state->msg); 497if(read_commit_msg(state) <0) 498die(_("'%s' was deleted by the applypatch-msg hook"), 499am_path(state,"final-commit")); 500} 501 502return ret; 503} 504 505/** 506 * Runs post-rewrite hook. Returns it exit code. 507 */ 508static intrun_post_rewrite_hook(const struct am_state *state) 509{ 510struct child_process cp = CHILD_PROCESS_INIT; 511const char*hook =find_hook("post-rewrite"); 512int ret; 513 514if(!hook) 515return0; 516 517argv_array_push(&cp.args, hook); 518argv_array_push(&cp.args,"rebase"); 519 520 cp.in =xopen(am_path(state,"rewritten"), O_RDONLY); 521 cp.stdout_to_stderr =1; 522 523 ret =run_command(&cp); 524 525close(cp.in); 526return ret; 527} 528 529/** 530 * Reads the state directory's "rewritten" file, and copies notes from the old 531 * commits listed in the file to their rewritten commits. 532 * 533 * Returns 0 on success, -1 on failure. 534 */ 535static intcopy_notes_for_rebase(const struct am_state *state) 536{ 537struct notes_rewrite_cfg *c; 538struct strbuf sb = STRBUF_INIT; 539const char*invalid_line =_("Malformed input line: '%s'."); 540const char*msg ="Notes added by 'git rebase'"; 541FILE*fp; 542int ret =0; 543 544assert(state->rebasing); 545 546 c =init_copy_notes_for_rewrite("rebase"); 547if(!c) 548return0; 549 550 fp =xfopen(am_path(state,"rewritten"),"r"); 551 552while(!strbuf_getline_lf(&sb, fp)) { 553struct object_id from_obj, to_obj; 554 555if(sb.len != GIT_SHA1_HEXSZ *2+1) { 556 ret =error(invalid_line, sb.buf); 557goto finish; 558} 559 560if(get_oid_hex(sb.buf, &from_obj)) { 561 ret =error(invalid_line, sb.buf); 562goto finish; 563} 564 565if(sb.buf[GIT_SHA1_HEXSZ] !=' ') { 566 ret =error(invalid_line, sb.buf); 567goto finish; 568} 569 570if(get_oid_hex(sb.buf + GIT_SHA1_HEXSZ +1, &to_obj)) { 571 ret =error(invalid_line, sb.buf); 572goto finish; 573} 574 575if(copy_note_for_rewrite(c, &from_obj, &to_obj)) 576 ret =error(_("Failed to copy notes from '%s' to '%s'"), 577oid_to_hex(&from_obj),oid_to_hex(&to_obj)); 578} 579 580finish: 581finish_copy_notes_for_rewrite(c, msg); 582fclose(fp); 583strbuf_release(&sb); 584return ret; 585} 586 587/** 588 * Determines if the file looks like a piece of RFC2822 mail by grabbing all 589 * non-indented lines and checking if they look like they begin with valid 590 * header field names. 591 * 592 * Returns 1 if the file looks like a piece of mail, 0 otherwise. 593 */ 594static intis_mail(FILE*fp) 595{ 596const char*header_regex ="^[!-9;-~]+:"; 597struct strbuf sb = STRBUF_INIT; 598 regex_t regex; 599int ret =1; 600 601if(fseek(fp,0L, SEEK_SET)) 602die_errno(_("fseek failed")); 603 604if(regcomp(®ex, header_regex, REG_NOSUB | REG_EXTENDED)) 605die("invalid pattern:%s", header_regex); 606 607while(!strbuf_getline(&sb, fp)) { 608if(!sb.len) 609break;/* End of header */ 610 611/* Ignore indented folded lines */ 612if(*sb.buf =='\t'|| *sb.buf ==' ') 613continue; 614 615/* It's a header if it matches header_regex */ 616if(regexec(®ex, sb.buf,0, NULL,0)) { 617 ret =0; 618goto done; 619} 620} 621 622done: 623regfree(®ex); 624strbuf_release(&sb); 625return ret; 626} 627 628/** 629 * Attempts to detect the patch_format of the patches contained in `paths`, 630 * returning the PATCH_FORMAT_* enum value. Returns PATCH_FORMAT_UNKNOWN if 631 * detection fails. 632 */ 633static intdetect_patch_format(const char**paths) 634{ 635enum patch_format ret = PATCH_FORMAT_UNKNOWN; 636struct strbuf l1 = STRBUF_INIT; 637struct strbuf l2 = STRBUF_INIT; 638struct strbuf l3 = STRBUF_INIT; 639FILE*fp; 640 641/* 642 * We default to mbox format if input is from stdin and for directories 643 */ 644if(!*paths || !strcmp(*paths,"-") ||is_directory(*paths)) 645return PATCH_FORMAT_MBOX; 646 647/* 648 * Otherwise, check the first few lines of the first patch, starting 649 * from the first non-blank line, to try to detect its format. 650 */ 651 652 fp =xfopen(*paths,"r"); 653 654while(!strbuf_getline(&l1, fp)) { 655if(l1.len) 656break; 657} 658 659if(starts_with(l1.buf,"From ") ||starts_with(l1.buf,"From: ")) { 660 ret = PATCH_FORMAT_MBOX; 661goto done; 662} 663 664if(starts_with(l1.buf,"# This series applies on GIT commit")) { 665 ret = PATCH_FORMAT_STGIT_SERIES; 666goto done; 667} 668 669if(!strcmp(l1.buf,"# HG changeset patch")) { 670 ret = PATCH_FORMAT_HG; 671goto done; 672} 673 674strbuf_getline(&l2, fp); 675strbuf_getline(&l3, fp); 676 677/* 678 * If the second line is empty and the third is a From, Author or Date 679 * entry, this is likely an StGit patch. 680 */ 681if(l1.len && !l2.len && 682(starts_with(l3.buf,"From:") || 683starts_with(l3.buf,"Author:") || 684starts_with(l3.buf,"Date:"))) { 685 ret = PATCH_FORMAT_STGIT; 686goto done; 687} 688 689if(l1.len &&is_mail(fp)) { 690 ret = PATCH_FORMAT_MBOX; 691goto done; 692} 693 694done: 695fclose(fp); 696strbuf_release(&l1); 697strbuf_release(&l2); 698strbuf_release(&l3); 699return ret; 700} 701 702/** 703 * Splits out individual email patches from `paths`, where each path is either 704 * a mbox file or a Maildir. Returns 0 on success, -1 on failure. 705 */ 706static intsplit_mail_mbox(struct am_state *state,const char**paths, 707int keep_cr,int mboxrd) 708{ 709struct child_process cp = CHILD_PROCESS_INIT; 710struct strbuf last = STRBUF_INIT; 711 712 cp.git_cmd =1; 713argv_array_push(&cp.args,"mailsplit"); 714argv_array_pushf(&cp.args,"-d%d", state->prec); 715argv_array_pushf(&cp.args,"-o%s", state->dir); 716argv_array_push(&cp.args,"-b"); 717if(keep_cr) 718argv_array_push(&cp.args,"--keep-cr"); 719if(mboxrd) 720argv_array_push(&cp.args,"--mboxrd"); 721argv_array_push(&cp.args,"--"); 722argv_array_pushv(&cp.args, paths); 723 724if(capture_command(&cp, &last,8)) 725return-1; 726 727 state->cur =1; 728 state->last =strtol(last.buf, NULL,10); 729 730return0; 731} 732 733/** 734 * Callback signature for split_mail_conv(). The foreign patch should be 735 * read from `in`, and the converted patch (in RFC2822 mail format) should be 736 * written to `out`. Return 0 on success, or -1 on failure. 737 */ 738typedefint(*mail_conv_fn)(FILE*out,FILE*in,int keep_cr); 739 740/** 741 * Calls `fn` for each file in `paths` to convert the foreign patch to the 742 * RFC2822 mail format suitable for parsing with git-mailinfo. 743 * 744 * Returns 0 on success, -1 on failure. 745 */ 746static intsplit_mail_conv(mail_conv_fn fn,struct am_state *state, 747const char**paths,int keep_cr) 748{ 749static const char*stdin_only[] = {"-", NULL}; 750int i; 751 752if(!*paths) 753 paths = stdin_only; 754 755for(i =0; *paths; paths++, i++) { 756FILE*in, *out; 757const char*mail; 758int ret; 759 760if(!strcmp(*paths,"-")) 761 in = stdin; 762else 763 in =fopen(*paths,"r"); 764 765if(!in) 766returnerror_errno(_("could not open '%s' for reading"), 767*paths); 768 769 mail =mkpath("%s/%0*d", state->dir, state->prec, i +1); 770 771 out =fopen(mail,"w"); 772if(!out) { 773if(in != stdin) 774fclose(in); 775returnerror_errno(_("could not open '%s' for writing"), 776 mail); 777} 778 779 ret =fn(out, in, keep_cr); 780 781fclose(out); 782if(in != stdin) 783fclose(in); 784 785if(ret) 786returnerror(_("could not parse patch '%s'"), *paths); 787} 788 789 state->cur =1; 790 state->last = i; 791return0; 792} 793 794/** 795 * A split_mail_conv() callback that converts an StGit patch to an RFC2822 796 * message suitable for parsing with git-mailinfo. 797 */ 798static intstgit_patch_to_mail(FILE*out,FILE*in,int keep_cr) 799{ 800struct strbuf sb = STRBUF_INIT; 801int subject_printed =0; 802 803while(!strbuf_getline_lf(&sb, in)) { 804const char*str; 805 806if(str_isspace(sb.buf)) 807continue; 808else if(skip_prefix(sb.buf,"Author:", &str)) 809fprintf(out,"From:%s\n", str); 810else if(starts_with(sb.buf,"From") ||starts_with(sb.buf,"Date")) 811fprintf(out,"%s\n", sb.buf); 812else if(!subject_printed) { 813fprintf(out,"Subject:%s\n", sb.buf); 814 subject_printed =1; 815}else{ 816fprintf(out,"\n%s\n", sb.buf); 817break; 818} 819} 820 821strbuf_reset(&sb); 822while(strbuf_fread(&sb,8192, in) >0) { 823fwrite(sb.buf,1, sb.len, out); 824strbuf_reset(&sb); 825} 826 827strbuf_release(&sb); 828return0; 829} 830 831/** 832 * This function only supports a single StGit series file in `paths`. 833 * 834 * Given an StGit series file, converts the StGit patches in the series into 835 * RFC2822 messages suitable for parsing with git-mailinfo, and queues them in 836 * the state directory. 837 * 838 * Returns 0 on success, -1 on failure. 839 */ 840static intsplit_mail_stgit_series(struct am_state *state,const char**paths, 841int keep_cr) 842{ 843const char*series_dir; 844char*series_dir_buf; 845FILE*fp; 846struct argv_array patches = ARGV_ARRAY_INIT; 847struct strbuf sb = STRBUF_INIT; 848int ret; 849 850if(!paths[0] || paths[1]) 851returnerror(_("Only one StGIT patch series can be applied at once")); 852 853 series_dir_buf =xstrdup(*paths); 854 series_dir =dirname(series_dir_buf); 855 856 fp =fopen(*paths,"r"); 857if(!fp) 858returnerror_errno(_("could not open '%s' for reading"), *paths); 859 860while(!strbuf_getline_lf(&sb, fp)) { 861if(*sb.buf =='#') 862continue;/* skip comment lines */ 863 864argv_array_push(&patches,mkpath("%s/%s", series_dir, sb.buf)); 865} 866 867fclose(fp); 868strbuf_release(&sb); 869free(series_dir_buf); 870 871 ret =split_mail_conv(stgit_patch_to_mail, state, patches.argv, keep_cr); 872 873argv_array_clear(&patches); 874return ret; 875} 876 877/** 878 * A split_patches_conv() callback that converts a mercurial patch to a RFC2822 879 * message suitable for parsing with git-mailinfo. 880 */ 881static inthg_patch_to_mail(FILE*out,FILE*in,int keep_cr) 882{ 883struct strbuf sb = STRBUF_INIT; 884int rc =0; 885 886while(!strbuf_getline_lf(&sb, in)) { 887const char*str; 888 889if(skip_prefix(sb.buf,"# User ", &str)) 890fprintf(out,"From:%s\n", str); 891else if(skip_prefix(sb.buf,"# Date ", &str)) { 892 timestamp_t timestamp; 893long tz, tz2; 894char*end; 895 896 errno =0; 897 timestamp =parse_timestamp(str, &end,10); 898if(errno) { 899 rc =error(_("invalid timestamp")); 900goto exit; 901} 902 903if(!skip_prefix(end," ", &str)) { 904 rc =error(_("invalid Date line")); 905goto exit; 906} 907 908 errno =0; 909 tz =strtol(str, &end,10); 910if(errno) { 911 rc =error(_("invalid timezone offset")); 912goto exit; 913} 914 915if(*end) { 916 rc =error(_("invalid Date line")); 917goto exit; 918} 919 920/* 921 * mercurial's timezone is in seconds west of UTC, 922 * however git's timezone is in hours + minutes east of 923 * UTC. Convert it. 924 */ 925 tz2 =labs(tz) /3600*100+labs(tz) %3600/60; 926if(tz >0) 927 tz2 = -tz2; 928 929fprintf(out,"Date:%s\n",show_date(timestamp, tz2,DATE_MODE(RFC2822))); 930}else if(starts_with(sb.buf,"# ")) { 931continue; 932}else{ 933fprintf(out,"\n%s\n", sb.buf); 934break; 935} 936} 937 938strbuf_reset(&sb); 939while(strbuf_fread(&sb,8192, in) >0) { 940fwrite(sb.buf,1, sb.len, out); 941strbuf_reset(&sb); 942} 943exit: 944strbuf_release(&sb); 945return rc; 946} 947 948/** 949 * Splits a list of files/directories into individual email patches. Each path 950 * in `paths` must be a file/directory that is formatted according to 951 * `patch_format`. 952 * 953 * Once split out, the individual email patches will be stored in the state 954 * directory, with each patch's filename being its index, padded to state->prec 955 * digits. 956 * 957 * state->cur will be set to the index of the first mail, and state->last will 958 * be set to the index of the last mail. 959 * 960 * Set keep_cr to 0 to convert all lines ending with \r\n to end with \n, 1 961 * to disable this behavior, -1 to use the default configured setting. 962 * 963 * Returns 0 on success, -1 on failure. 964 */ 965static intsplit_mail(struct am_state *state,enum patch_format patch_format, 966const char**paths,int keep_cr) 967{ 968if(keep_cr <0) { 969 keep_cr =0; 970git_config_get_bool("am.keepcr", &keep_cr); 971} 972 973switch(patch_format) { 974case PATCH_FORMAT_MBOX: 975returnsplit_mail_mbox(state, paths, keep_cr,0); 976case PATCH_FORMAT_STGIT: 977returnsplit_mail_conv(stgit_patch_to_mail, state, paths, keep_cr); 978case PATCH_FORMAT_STGIT_SERIES: 979returnsplit_mail_stgit_series(state, paths, keep_cr); 980case PATCH_FORMAT_HG: 981returnsplit_mail_conv(hg_patch_to_mail, state, paths, keep_cr); 982case PATCH_FORMAT_MBOXRD: 983returnsplit_mail_mbox(state, paths, keep_cr,1); 984default: 985die("BUG: invalid patch_format"); 986} 987return-1; 988} 989 990/** 991 * Setup a new am session for applying patches 992 */ 993static voidam_setup(struct am_state *state,enum patch_format patch_format, 994const char**paths,int keep_cr) 995{ 996struct object_id curr_head; 997const char*str; 998struct strbuf sb = STRBUF_INIT; 9991000if(!patch_format)1001 patch_format =detect_patch_format(paths);10021003if(!patch_format) {1004fprintf_ln(stderr,_("Patch format detection failed."));1005exit(128);1006}10071008if(mkdir(state->dir,0777) <0&& errno != EEXIST)1009die_errno(_("failed to create directory '%s'"), state->dir);10101011if(split_mail(state, patch_format, paths, keep_cr) <0) {1012am_destroy(state);1013die(_("Failed to split patches."));1014}10151016if(state->rebasing)1017 state->threeway =1;10181019write_state_bool(state,"threeway", state->threeway);1020write_state_bool(state,"quiet", state->quiet);1021write_state_bool(state,"sign", state->signoff);1022write_state_bool(state,"utf8", state->utf8);10231024if(state->allow_rerere_autoupdate)1025write_state_bool(state,"rerere-autoupdate",1026 state->allow_rerere_autoupdate == RERERE_AUTOUPDATE);10271028switch(state->keep) {1029case KEEP_FALSE:1030 str ="f";1031break;1032case KEEP_TRUE:1033 str ="t";1034break;1035case KEEP_NON_PATCH:1036 str ="b";1037break;1038default:1039die("BUG: invalid value for state->keep");1040}10411042write_state_text(state,"keep", str);1043write_state_bool(state,"messageid", state->message_id);10441045switch(state->scissors) {1046case SCISSORS_UNSET:1047 str ="";1048break;1049case SCISSORS_FALSE:1050 str ="f";1051break;1052case SCISSORS_TRUE:1053 str ="t";1054break;1055default:1056die("BUG: invalid value for state->scissors");1057}1058write_state_text(state,"scissors", str);10591060sq_quote_argv(&sb, state->git_apply_opts.argv,0);1061write_state_text(state,"apply-opt", sb.buf);10621063if(state->rebasing)1064write_state_text(state,"rebasing","");1065else1066write_state_text(state,"applying","");10671068if(!get_oid("HEAD", &curr_head)) {1069write_state_text(state,"abort-safety",oid_to_hex(&curr_head));1070if(!state->rebasing)1071update_ref("am","ORIG_HEAD", &curr_head, NULL,0,1072 UPDATE_REFS_DIE_ON_ERR);1073}else{1074write_state_text(state,"abort-safety","");1075if(!state->rebasing)1076delete_ref(NULL,"ORIG_HEAD", NULL,0);1077}10781079/*1080 * NOTE: Since the "next" and "last" files determine if an am_state1081 * session is in progress, they should be written last.1082 */10831084write_state_count(state,"next", state->cur);1085write_state_count(state,"last", state->last);10861087strbuf_release(&sb);1088}10891090/**1091 * Increments the patch pointer, and cleans am_state for the application of the1092 * next patch.1093 */1094static voidam_next(struct am_state *state)1095{1096struct object_id head;10971098FREE_AND_NULL(state->author_name);1099FREE_AND_NULL(state->author_email);1100FREE_AND_NULL(state->author_date);1101FREE_AND_NULL(state->msg);1102 state->msg_len =0;11031104unlink(am_path(state,"author-script"));1105unlink(am_path(state,"final-commit"));11061107oidclr(&state->orig_commit);1108unlink(am_path(state,"original-commit"));11091110if(!get_oid("HEAD", &head))1111write_state_text(state,"abort-safety",oid_to_hex(&head));1112else1113write_state_text(state,"abort-safety","");11141115 state->cur++;1116write_state_count(state,"next", state->cur);1117}11181119/**1120 * Returns the filename of the current patch email.1121 */1122static const char*msgnum(const struct am_state *state)1123{1124static struct strbuf sb = STRBUF_INIT;11251126strbuf_reset(&sb);1127strbuf_addf(&sb,"%0*d", state->prec, state->cur);11281129return sb.buf;1130}11311132/**1133 * Refresh and write index.1134 */1135static voidrefresh_and_write_cache(void)1136{1137struct lock_file lock_file = LOCK_INIT;11381139hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);1140refresh_cache(REFRESH_QUIET);1141if(write_locked_index(&the_index, &lock_file, COMMIT_LOCK))1142die(_("unable to write index file"));1143}11441145/**1146 * Returns 1 if the index differs from HEAD, 0 otherwise. When on an unborn1147 * branch, returns 1 if there are entries in the index, 0 otherwise. If an1148 * strbuf is provided, the space-separated list of files that differ will be1149 * appended to it.1150 */1151static intindex_has_changes(struct strbuf *sb)1152{1153struct object_id head;1154int i;11551156if(!get_oid_tree("HEAD", &head)) {1157struct diff_options opt;11581159diff_setup(&opt);1160 opt.flags.exit_with_status =1;1161if(!sb)1162 opt.flags.quick =1;1163do_diff_cache(&head, &opt);1164diffcore_std(&opt);1165for(i =0; sb && i < diff_queued_diff.nr; i++) {1166if(i)1167strbuf_addch(sb,' ');1168strbuf_addstr(sb, diff_queued_diff.queue[i]->two->path);1169}1170diff_flush(&opt);1171return opt.flags.has_changes !=0;1172}else{1173for(i =0; sb && i < active_nr; i++) {1174if(i)1175strbuf_addch(sb,' ');1176strbuf_addstr(sb, active_cache[i]->name);1177}1178return!!active_nr;1179}1180}11811182/**1183 * Dies with a user-friendly message on how to proceed after resolving the1184 * problem. This message can be overridden with state->resolvemsg.1185 */1186static void NORETURN die_user_resolve(const struct am_state *state)1187{1188if(state->resolvemsg) {1189printf_ln("%s", state->resolvemsg);1190}else{1191const char*cmdline = state->interactive ?"git am -i":"git am";11921193printf_ln(_("When you have resolved this problem, run\"%s--continue\"."), cmdline);1194printf_ln(_("If you prefer to skip this patch, run\"%s--skip\"instead."), cmdline);1195printf_ln(_("To restore the original branch and stop patching, run\"%s--abort\"."), cmdline);1196}11971198exit(128);1199}12001201/**1202 * Appends signoff to the "msg" field of the am_state.1203 */1204static voidam_append_signoff(struct am_state *state)1205{1206struct strbuf sb = STRBUF_INIT;12071208strbuf_attach(&sb, state->msg, state->msg_len, state->msg_len);1209append_signoff(&sb,0,0);1210 state->msg =strbuf_detach(&sb, &state->msg_len);1211}12121213/**1214 * Parses `mail` using git-mailinfo, extracting its patch and authorship info.1215 * state->msg will be set to the patch message. state->author_name,1216 * state->author_email and state->author_date will be set to the patch author's1217 * name, email and date respectively. The patch body will be written to the1218 * state directory's "patch" file.1219 *1220 * Returns 1 if the patch should be skipped, 0 otherwise.1221 */1222static intparse_mail(struct am_state *state,const char*mail)1223{1224FILE*fp;1225struct strbuf sb = STRBUF_INIT;1226struct strbuf msg = STRBUF_INIT;1227struct strbuf author_name = STRBUF_INIT;1228struct strbuf author_date = STRBUF_INIT;1229struct strbuf author_email = STRBUF_INIT;1230int ret =0;1231struct mailinfo mi;12321233setup_mailinfo(&mi);12341235if(state->utf8)1236 mi.metainfo_charset =get_commit_output_encoding();1237else1238 mi.metainfo_charset = NULL;12391240switch(state->keep) {1241case KEEP_FALSE:1242break;1243case KEEP_TRUE:1244 mi.keep_subject =1;1245break;1246case KEEP_NON_PATCH:1247 mi.keep_non_patch_brackets_in_subject =1;1248break;1249default:1250die("BUG: invalid value for state->keep");1251}12521253if(state->message_id)1254 mi.add_message_id =1;12551256switch(state->scissors) {1257case SCISSORS_UNSET:1258break;1259case SCISSORS_FALSE:1260 mi.use_scissors =0;1261break;1262case SCISSORS_TRUE:1263 mi.use_scissors =1;1264break;1265default:1266die("BUG: invalid value for state->scissors");1267}12681269 mi.input =xfopen(mail,"r");1270 mi.output =xfopen(am_path(state,"info"),"w");1271if(mailinfo(&mi,am_path(state,"msg"),am_path(state,"patch")))1272die("could not parse patch");12731274fclose(mi.input);1275fclose(mi.output);12761277/* Extract message and author information */1278 fp =xfopen(am_path(state,"info"),"r");1279while(!strbuf_getline_lf(&sb, fp)) {1280const char*x;12811282if(skip_prefix(sb.buf,"Subject: ", &x)) {1283if(msg.len)1284strbuf_addch(&msg,'\n');1285strbuf_addstr(&msg, x);1286}else if(skip_prefix(sb.buf,"Author: ", &x))1287strbuf_addstr(&author_name, x);1288else if(skip_prefix(sb.buf,"Email: ", &x))1289strbuf_addstr(&author_email, x);1290else if(skip_prefix(sb.buf,"Date: ", &x))1291strbuf_addstr(&author_date, x);1292}1293fclose(fp);12941295/* Skip pine's internal folder data */1296if(!strcmp(author_name.buf,"Mail System Internal Data")) {1297 ret =1;1298goto finish;1299}13001301if(is_empty_file(am_path(state,"patch"))) {1302printf_ln(_("Patch is empty."));1303die_user_resolve(state);1304}13051306strbuf_addstr(&msg,"\n\n");1307strbuf_addbuf(&msg, &mi.log_message);1308strbuf_stripspace(&msg,0);13091310assert(!state->author_name);1311 state->author_name =strbuf_detach(&author_name, NULL);13121313assert(!state->author_email);1314 state->author_email =strbuf_detach(&author_email, NULL);13151316assert(!state->author_date);1317 state->author_date =strbuf_detach(&author_date, NULL);13181319assert(!state->msg);1320 state->msg =strbuf_detach(&msg, &state->msg_len);13211322finish:1323strbuf_release(&msg);1324strbuf_release(&author_date);1325strbuf_release(&author_email);1326strbuf_release(&author_name);1327strbuf_release(&sb);1328clear_mailinfo(&mi);1329return ret;1330}13311332/**1333 * Sets commit_id to the commit hash where the mail was generated from.1334 * Returns 0 on success, -1 on failure.1335 */1336static intget_mail_commit_oid(struct object_id *commit_id,const char*mail)1337{1338struct strbuf sb = STRBUF_INIT;1339FILE*fp =xfopen(mail,"r");1340const char*x;1341int ret =0;13421343if(strbuf_getline_lf(&sb, fp) ||1344!skip_prefix(sb.buf,"From ", &x) ||1345get_oid_hex(x, commit_id) <0)1346 ret = -1;13471348strbuf_release(&sb);1349fclose(fp);1350return ret;1351}13521353/**1354 * Sets state->msg, state->author_name, state->author_email, state->author_date1355 * to the commit's respective info.1356 */1357static voidget_commit_info(struct am_state *state,struct commit *commit)1358{1359const char*buffer, *ident_line, *msg;1360size_t ident_len;1361struct ident_split id;13621363 buffer =logmsg_reencode(commit, NULL,get_commit_output_encoding());13641365 ident_line =find_commit_header(buffer,"author", &ident_len);13661367if(split_ident_line(&id, ident_line, ident_len) <0)1368die(_("invalid ident line: %.*s"), (int)ident_len, ident_line);13691370assert(!state->author_name);1371if(id.name_begin)1372 state->author_name =1373xmemdupz(id.name_begin, id.name_end - id.name_begin);1374else1375 state->author_name =xstrdup("");13761377assert(!state->author_email);1378if(id.mail_begin)1379 state->author_email =1380xmemdupz(id.mail_begin, id.mail_end - id.mail_begin);1381else1382 state->author_email =xstrdup("");13831384assert(!state->author_date);1385 state->author_date =xstrdup(show_ident_date(&id,DATE_MODE(NORMAL)));13861387assert(!state->msg);1388 msg =strstr(buffer,"\n\n");1389if(!msg)1390die(_("unable to parse commit%s"),oid_to_hex(&commit->object.oid));1391 state->msg =xstrdup(msg +2);1392 state->msg_len =strlen(state->msg);1393unuse_commit_buffer(commit, buffer);1394}13951396/**1397 * Writes `commit` as a patch to the state directory's "patch" file.1398 */1399static voidwrite_commit_patch(const struct am_state *state,struct commit *commit)1400{1401struct rev_info rev_info;1402FILE*fp;14031404 fp =xfopen(am_path(state,"patch"),"w");1405init_revisions(&rev_info, NULL);1406 rev_info.diff =1;1407 rev_info.abbrev =0;1408 rev_info.disable_stdin =1;1409 rev_info.show_root_diff =1;1410 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;1411 rev_info.no_commit_id =1;1412 rev_info.diffopt.flags.binary =1;1413 rev_info.diffopt.flags.full_index =1;1414 rev_info.diffopt.use_color =0;1415 rev_info.diffopt.file = fp;1416 rev_info.diffopt.close_file =1;1417add_pending_object(&rev_info, &commit->object,"");1418diff_setup_done(&rev_info.diffopt);1419log_tree_commit(&rev_info, commit);1420}14211422/**1423 * Writes the diff of the index against HEAD as a patch to the state1424 * directory's "patch" file.1425 */1426static voidwrite_index_patch(const struct am_state *state)1427{1428struct tree *tree;1429struct object_id head;1430struct rev_info rev_info;1431FILE*fp;14321433if(!get_oid_tree("HEAD", &head))1434 tree =lookup_tree(&head);1435else1436 tree =lookup_tree(&empty_tree_oid);14371438 fp =xfopen(am_path(state,"patch"),"w");1439init_revisions(&rev_info, NULL);1440 rev_info.diff =1;1441 rev_info.disable_stdin =1;1442 rev_info.no_commit_id =1;1443 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;1444 rev_info.diffopt.use_color =0;1445 rev_info.diffopt.file = fp;1446 rev_info.diffopt.close_file =1;1447add_pending_object(&rev_info, &tree->object,"");1448diff_setup_done(&rev_info.diffopt);1449run_diff_index(&rev_info,1);1450}14511452/**1453 * Like parse_mail(), but parses the mail by looking up its commit ID1454 * directly. This is used in --rebasing mode to bypass git-mailinfo's munging1455 * of patches.1456 *1457 * state->orig_commit will be set to the original commit ID.1458 *1459 * Will always return 0 as the patch should never be skipped.1460 */1461static intparse_mail_rebase(struct am_state *state,const char*mail)1462{1463struct commit *commit;1464struct object_id commit_oid;14651466if(get_mail_commit_oid(&commit_oid, mail) <0)1467die(_("could not parse%s"), mail);14681469 commit =lookup_commit_or_die(&commit_oid, mail);14701471get_commit_info(state, commit);14721473write_commit_patch(state, commit);14741475oidcpy(&state->orig_commit, &commit_oid);1476write_state_text(state,"original-commit",oid_to_hex(&commit_oid));14771478return0;1479}14801481/**1482 * Applies current patch with git-apply. Returns 0 on success, -1 otherwise. If1483 * `index_file` is not NULL, the patch will be applied to that index.1484 */1485static intrun_apply(const struct am_state *state,const char*index_file)1486{1487struct argv_array apply_paths = ARGV_ARRAY_INIT;1488struct argv_array apply_opts = ARGV_ARRAY_INIT;1489struct apply_state apply_state;1490int res, opts_left;1491int force_apply =0;1492int options =0;14931494if(init_apply_state(&apply_state, NULL))1495die("BUG: init_apply_state() failed");14961497argv_array_push(&apply_opts,"apply");1498argv_array_pushv(&apply_opts, state->git_apply_opts.argv);14991500 opts_left =apply_parse_options(apply_opts.argc, apply_opts.argv,1501&apply_state, &force_apply, &options,1502 NULL);15031504if(opts_left !=0)1505die("unknown option passed through to git apply");15061507if(index_file) {1508 apply_state.index_file = index_file;1509 apply_state.cached =1;1510}else1511 apply_state.check_index =1;15121513/*1514 * If we are allowed to fall back on 3-way merge, don't give false1515 * errors during the initial attempt.1516 */1517if(state->threeway && !index_file)1518 apply_state.apply_verbosity = verbosity_silent;15191520if(check_apply_state(&apply_state, force_apply))1521die("BUG: check_apply_state() failed");15221523argv_array_push(&apply_paths,am_path(state,"patch"));15241525 res =apply_all_patches(&apply_state, apply_paths.argc, apply_paths.argv, options);15261527argv_array_clear(&apply_paths);1528argv_array_clear(&apply_opts);1529clear_apply_state(&apply_state);15301531if(res)1532return res;15331534if(index_file) {1535/* Reload index as apply_all_patches() will have modified it. */1536discard_cache();1537read_cache_from(index_file);1538}15391540return0;1541}15421543/**1544 * Builds an index that contains just the blobs needed for a 3way merge.1545 */1546static intbuild_fake_ancestor(const struct am_state *state,const char*index_file)1547{1548struct child_process cp = CHILD_PROCESS_INIT;15491550 cp.git_cmd =1;1551argv_array_push(&cp.args,"apply");1552argv_array_pushv(&cp.args, state->git_apply_opts.argv);1553argv_array_pushf(&cp.args,"--build-fake-ancestor=%s", index_file);1554argv_array_push(&cp.args,am_path(state,"patch"));15551556if(run_command(&cp))1557return-1;15581559return0;1560}15611562/**1563 * Attempt a threeway merge, using index_path as the temporary index.1564 */1565static intfall_back_threeway(const struct am_state *state,const char*index_path)1566{1567struct object_id orig_tree, their_tree, our_tree;1568const struct object_id *bases[1] = { &orig_tree };1569struct merge_options o;1570struct commit *result;1571char*their_tree_name;15721573if(get_oid("HEAD", &our_tree) <0)1574hashcpy(our_tree.hash, EMPTY_TREE_SHA1_BIN);15751576if(build_fake_ancestor(state, index_path))1577returnerror("could not build fake ancestor");15781579discard_cache();1580read_cache_from(index_path);15811582if(write_index_as_tree(orig_tree.hash, &the_index, index_path,0, NULL))1583returnerror(_("Repository lacks necessary blobs to fall back on 3-way merge."));15841585say(state, stdout,_("Using index info to reconstruct a base tree..."));15861587if(!state->quiet) {1588/*1589 * List paths that needed 3-way fallback, so that the user can1590 * review them with extra care to spot mismerges.1591 */1592struct rev_info rev_info;1593const char*diff_filter_str ="--diff-filter=AM";15941595init_revisions(&rev_info, NULL);1596 rev_info.diffopt.output_format = DIFF_FORMAT_NAME_STATUS;1597diff_opt_parse(&rev_info.diffopt, &diff_filter_str,1, rev_info.prefix);1598add_pending_oid(&rev_info,"HEAD", &our_tree,0);1599diff_setup_done(&rev_info.diffopt);1600run_diff_index(&rev_info,1);1601}16021603if(run_apply(state, index_path))1604returnerror(_("Did you hand edit your patch?\n"1605"It does not apply to blobs recorded in its index."));16061607if(write_index_as_tree(their_tree.hash, &the_index, index_path,0, NULL))1608returnerror("could not write tree");16091610say(state, stdout,_("Falling back to patching base and 3-way merge..."));16111612discard_cache();1613read_cache();16141615/*1616 * This is not so wrong. Depending on which base we picked, orig_tree1617 * may be wildly different from ours, but their_tree has the same set of1618 * wildly different changes in parts the patch did not touch, so1619 * recursive ends up canceling them, saying that we reverted all those1620 * changes.1621 */16221623init_merge_options(&o);16241625 o.branch1 ="HEAD";1626 their_tree_name =xstrfmt("%.*s",linelen(state->msg), state->msg);1627 o.branch2 = their_tree_name;16281629if(state->quiet)1630 o.verbosity =0;16311632if(merge_recursive_generic(&o, &our_tree, &their_tree,1, bases, &result)) {1633rerere(state->allow_rerere_autoupdate);1634free(their_tree_name);1635returnerror(_("Failed to merge in the changes."));1636}16371638free(their_tree_name);1639return0;1640}16411642/**1643 * Commits the current index with state->msg as the commit message and1644 * state->author_name, state->author_email and state->author_date as the author1645 * information.1646 */1647static voiddo_commit(const struct am_state *state)1648{1649struct object_id tree, parent, commit;1650const struct object_id *old_oid;1651struct commit_list *parents = NULL;1652const char*reflog_msg, *author;1653struct strbuf sb = STRBUF_INIT;16541655if(run_hook_le(NULL,"pre-applypatch", NULL))1656exit(1);16571658if(write_cache_as_tree(tree.hash,0, NULL))1659die(_("git write-tree failed to write a tree"));16601661if(!get_oid_commit("HEAD", &parent)) {1662 old_oid = &parent;1663commit_list_insert(lookup_commit(&parent), &parents);1664}else{1665 old_oid = NULL;1666say(state, stderr,_("applying to an empty history"));1667}16681669 author =fmt_ident(state->author_name, state->author_email,1670 state->ignore_date ? NULL : state->author_date,1671 IDENT_STRICT);16721673if(state->committer_date_is_author_date)1674setenv("GIT_COMMITTER_DATE",1675 state->ignore_date ?"": state->author_date,1);16761677if(commit_tree(state->msg, state->msg_len, tree.hash, parents, commit.hash,1678 author, state->sign_commit))1679die(_("failed to write commit object"));16801681 reflog_msg =getenv("GIT_REFLOG_ACTION");1682if(!reflog_msg)1683 reflog_msg ="am";16841685strbuf_addf(&sb,"%s: %.*s", reflog_msg,linelen(state->msg),1686 state->msg);16871688update_ref(sb.buf,"HEAD", &commit, old_oid,0,1689 UPDATE_REFS_DIE_ON_ERR);16901691if(state->rebasing) {1692FILE*fp =xfopen(am_path(state,"rewritten"),"a");16931694assert(!is_null_oid(&state->orig_commit));1695fprintf(fp,"%s",oid_to_hex(&state->orig_commit));1696fprintf(fp,"%s\n",oid_to_hex(&commit));1697fclose(fp);1698}16991700run_hook_le(NULL,"post-applypatch", NULL);17011702strbuf_release(&sb);1703}17041705/**1706 * Validates the am_state for resuming -- the "msg" and authorship fields must1707 * be filled up.1708 */1709static voidvalidate_resume_state(const struct am_state *state)1710{1711if(!state->msg)1712die(_("cannot resume:%sdoes not exist."),1713am_path(state,"final-commit"));17141715if(!state->author_name || !state->author_email || !state->author_date)1716die(_("cannot resume:%sdoes not exist."),1717am_path(state,"author-script"));1718}17191720/**1721 * Interactively prompt the user on whether the current patch should be1722 * applied.1723 *1724 * Returns 0 if the user chooses to apply the patch, 1 if the user chooses to1725 * skip it.1726 */1727static intdo_interactive(struct am_state *state)1728{1729assert(state->msg);17301731if(!isatty(0))1732die(_("cannot be interactive without stdin connected to a terminal."));17331734for(;;) {1735const char*reply;17361737puts(_("Commit Body is:"));1738puts("--------------------------");1739printf("%s", state->msg);1740puts("--------------------------");17411742/*1743 * TRANSLATORS: Make sure to include [y], [n], [e], [v] and [a]1744 * in your translation. The program will only accept English1745 * input at this point.1746 */1747 reply =git_prompt(_("Apply? [y]es/[n]o/[e]dit/[v]iew patch/[a]ccept all: "), PROMPT_ECHO);17481749if(!reply) {1750continue;1751}else if(*reply =='y'|| *reply =='Y') {1752return0;1753}else if(*reply =='a'|| *reply =='A') {1754 state->interactive =0;1755return0;1756}else if(*reply =='n'|| *reply =='N') {1757return1;1758}else if(*reply =='e'|| *reply =='E') {1759struct strbuf msg = STRBUF_INIT;17601761if(!launch_editor(am_path(state,"final-commit"), &msg, NULL)) {1762free(state->msg);1763 state->msg =strbuf_detach(&msg, &state->msg_len);1764}1765strbuf_release(&msg);1766}else if(*reply =='v'|| *reply =='V') {1767const char*pager =git_pager(1);1768struct child_process cp = CHILD_PROCESS_INIT;17691770if(!pager)1771 pager ="cat";1772prepare_pager_args(&cp, pager);1773argv_array_push(&cp.args,am_path(state,"patch"));1774run_command(&cp);1775}1776}1777}17781779/**1780 * Applies all queued mail.1781 *1782 * If `resume` is true, we are "resuming". The "msg" and authorship fields, as1783 * well as the state directory's "patch" file is used as-is for applying the1784 * patch and committing it.1785 */1786static voidam_run(struct am_state *state,int resume)1787{1788const char*argv_gc_auto[] = {"gc","--auto", NULL};1789struct strbuf sb = STRBUF_INIT;17901791unlink(am_path(state,"dirtyindex"));17921793refresh_and_write_cache();17941795if(index_has_changes(&sb)) {1796write_state_bool(state,"dirtyindex",1);1797die(_("Dirty index: cannot apply patches (dirty:%s)"), sb.buf);1798}17991800strbuf_release(&sb);18011802while(state->cur <= state->last) {1803const char*mail =am_path(state,msgnum(state));1804int apply_status;18051806reset_ident_date();18071808if(!file_exists(mail))1809goto next;18101811if(resume) {1812validate_resume_state(state);1813}else{1814int skip;18151816if(state->rebasing)1817 skip =parse_mail_rebase(state, mail);1818else1819 skip =parse_mail(state, mail);18201821if(skip)1822goto next;/* mail should be skipped */18231824if(state->signoff)1825am_append_signoff(state);18261827write_author_script(state);1828write_commit_msg(state);1829}18301831if(state->interactive &&do_interactive(state))1832goto next;18331834if(run_applypatch_msg_hook(state))1835exit(1);18361837say(state, stdout,_("Applying: %.*s"),linelen(state->msg), state->msg);18381839 apply_status =run_apply(state, NULL);18401841if(apply_status && state->threeway) {1842struct strbuf sb = STRBUF_INIT;18431844strbuf_addstr(&sb,am_path(state,"patch-merge-index"));1845 apply_status =fall_back_threeway(state, sb.buf);1846strbuf_release(&sb);18471848/*1849 * Applying the patch to an earlier tree and merging1850 * the result may have produced the same tree as ours.1851 */1852if(!apply_status && !index_has_changes(NULL)) {1853say(state, stdout,_("No changes -- Patch already applied."));1854goto next;1855}1856}18571858if(apply_status) {1859int advice_amworkdir =1;18601861printf_ln(_("Patch failed at%s%.*s"),msgnum(state),1862linelen(state->msg), state->msg);18631864git_config_get_bool("advice.amworkdir", &advice_amworkdir);18651866if(advice_amworkdir)1867printf_ln(_("The copy of the patch that failed is found in:%s"),1868am_path(state,"patch"));18691870die_user_resolve(state);1871}18721873do_commit(state);18741875next:1876am_next(state);18771878if(resume)1879am_load(state);1880 resume =0;1881}18821883if(!is_empty_file(am_path(state,"rewritten"))) {1884assert(state->rebasing);1885copy_notes_for_rebase(state);1886run_post_rewrite_hook(state);1887}18881889/*1890 * In rebasing mode, it's up to the caller to take care of1891 * housekeeping.1892 */1893if(!state->rebasing) {1894am_destroy(state);1895close_all_packs();1896run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);1897}1898}18991900/**1901 * Resume the current am session after patch application failure. The user did1902 * all the hard work, and we do not have to do any patch application. Just1903 * trust and commit what the user has in the index and working tree.1904 */1905static voidam_resolve(struct am_state *state)1906{1907validate_resume_state(state);19081909say(state, stdout,_("Applying: %.*s"),linelen(state->msg), state->msg);19101911if(!index_has_changes(NULL)) {1912printf_ln(_("No changes - did you forget to use 'git add'?\n"1913"If there is nothing left to stage, chances are that something else\n"1914"already introduced the same changes; you might want to skip this patch."));1915die_user_resolve(state);1916}19171918if(unmerged_cache()) {1919printf_ln(_("You still have unmerged paths in your index.\n"1920"You should 'git add' each file with resolved conflicts to mark them as such.\n"1921"You might run `git rm` on a file to accept\"deleted by them\"for it."));1922die_user_resolve(state);1923}19241925if(state->interactive) {1926write_index_patch(state);1927if(do_interactive(state))1928goto next;1929}19301931rerere(0);19321933do_commit(state);19341935next:1936am_next(state);1937am_load(state);1938am_run(state,0);1939}19401941/**1942 * Performs a checkout fast-forward from `head` to `remote`. If `reset` is1943 * true, any unmerged entries will be discarded. Returns 0 on success, -1 on1944 * failure.1945 */1946static intfast_forward_to(struct tree *head,struct tree *remote,int reset)1947{1948struct lock_file lock_file = LOCK_INIT;1949struct unpack_trees_options opts;1950struct tree_desc t[2];19511952if(parse_tree(head) ||parse_tree(remote))1953return-1;19541955hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);19561957refresh_cache(REFRESH_QUIET);19581959memset(&opts,0,sizeof(opts));1960 opts.head_idx =1;1961 opts.src_index = &the_index;1962 opts.dst_index = &the_index;1963 opts.update =1;1964 opts.merge =1;1965 opts.reset = reset;1966 opts.fn = twoway_merge;1967init_tree_desc(&t[0], head->buffer, head->size);1968init_tree_desc(&t[1], remote->buffer, remote->size);19691970if(unpack_trees(2, t, &opts)) {1971rollback_lock_file(&lock_file);1972return-1;1973}19741975if(write_locked_index(&the_index, &lock_file, COMMIT_LOCK))1976die(_("unable to write new index file"));19771978return0;1979}19801981/**1982 * Merges a tree into the index. The index's stat info will take precedence1983 * over the merged tree's. Returns 0 on success, -1 on failure.1984 */1985static intmerge_tree(struct tree *tree)1986{1987struct lock_file lock_file = LOCK_INIT;1988struct unpack_trees_options opts;1989struct tree_desc t[1];19901991if(parse_tree(tree))1992return-1;19931994hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);19951996memset(&opts,0,sizeof(opts));1997 opts.head_idx =1;1998 opts.src_index = &the_index;1999 opts.dst_index = &the_index;2000 opts.merge =1;2001 opts.fn = oneway_merge;2002init_tree_desc(&t[0], tree->buffer, tree->size);20032004if(unpack_trees(1, t, &opts)) {2005rollback_lock_file(&lock_file);2006return-1;2007}20082009if(write_locked_index(&the_index, &lock_file, COMMIT_LOCK))2010die(_("unable to write new index file"));20112012return0;2013}20142015/**2016 * Clean the index without touching entries that are not modified between2017 * `head` and `remote`.2018 */2019static intclean_index(const struct object_id *head,const struct object_id *remote)2020{2021struct tree *head_tree, *remote_tree, *index_tree;2022struct object_id index;20232024 head_tree =parse_tree_indirect(head);2025if(!head_tree)2026returnerror(_("Could not parse object '%s'."),oid_to_hex(head));20272028 remote_tree =parse_tree_indirect(remote);2029if(!remote_tree)2030returnerror(_("Could not parse object '%s'."),oid_to_hex(remote));20312032read_cache_unmerged();20332034if(fast_forward_to(head_tree, head_tree,1))2035return-1;20362037if(write_cache_as_tree(index.hash,0, NULL))2038return-1;20392040 index_tree =parse_tree_indirect(&index);2041if(!index_tree)2042returnerror(_("Could not parse object '%s'."),oid_to_hex(&index));20432044if(fast_forward_to(index_tree, remote_tree,0))2045return-1;20462047if(merge_tree(remote_tree))2048return-1;20492050remove_branch_state();20512052return0;2053}20542055/**2056 * Resets rerere's merge resolution metadata.2057 */2058static voidam_rerere_clear(void)2059{2060struct string_list merge_rr = STRING_LIST_INIT_DUP;2061rerere_clear(&merge_rr);2062string_list_clear(&merge_rr,1);2063}20642065/**2066 * Resume the current am session by skipping the current patch.2067 */2068static voidam_skip(struct am_state *state)2069{2070struct object_id head;20712072am_rerere_clear();20732074if(get_oid("HEAD", &head))2075hashcpy(head.hash, EMPTY_TREE_SHA1_BIN);20762077if(clean_index(&head, &head))2078die(_("failed to clean index"));20792080am_next(state);2081am_load(state);2082am_run(state,0);2083}20842085/**2086 * Returns true if it is safe to reset HEAD to the ORIG_HEAD, false otherwise.2087 *2088 * It is not safe to reset HEAD when:2089 * 1. git-am previously failed because the index was dirty.2090 * 2. HEAD has moved since git-am previously failed.2091 */2092static intsafe_to_abort(const struct am_state *state)2093{2094struct strbuf sb = STRBUF_INIT;2095struct object_id abort_safety, head;20962097if(file_exists(am_path(state,"dirtyindex")))2098return0;20992100if(read_state_file(&sb, state,"abort-safety",1) >0) {2101if(get_oid_hex(sb.buf, &abort_safety))2102die(_("could not parse%s"),am_path(state,"abort-safety"));2103}else2104oidclr(&abort_safety);2105strbuf_release(&sb);21062107if(get_oid("HEAD", &head))2108oidclr(&head);21092110if(!oidcmp(&head, &abort_safety))2111return1;21122113warning(_("You seem to have moved HEAD since the last 'am' failure.\n"2114"Not rewinding to ORIG_HEAD"));21152116return0;2117}21182119/**2120 * Aborts the current am session if it is safe to do so.2121 */2122static voidam_abort(struct am_state *state)2123{2124struct object_id curr_head, orig_head;2125int has_curr_head, has_orig_head;2126char*curr_branch;21272128if(!safe_to_abort(state)) {2129am_destroy(state);2130return;2131}21322133am_rerere_clear();21342135 curr_branch =resolve_refdup("HEAD",0, &curr_head, NULL);2136 has_curr_head = curr_branch && !is_null_oid(&curr_head);2137if(!has_curr_head)2138hashcpy(curr_head.hash, EMPTY_TREE_SHA1_BIN);21392140 has_orig_head = !get_oid("ORIG_HEAD", &orig_head);2141if(!has_orig_head)2142hashcpy(orig_head.hash, EMPTY_TREE_SHA1_BIN);21432144clean_index(&curr_head, &orig_head);21452146if(has_orig_head)2147update_ref("am --abort","HEAD", &orig_head,2148 has_curr_head ? &curr_head : NULL,0,2149 UPDATE_REFS_DIE_ON_ERR);2150else if(curr_branch)2151delete_ref(NULL, curr_branch, NULL, REF_NO_DEREF);21522153free(curr_branch);2154am_destroy(state);2155}21562157/**2158 * parse_options() callback that validates and sets opt->value to the2159 * PATCH_FORMAT_* enum value corresponding to `arg`.2160 */2161static intparse_opt_patchformat(const struct option *opt,const char*arg,int unset)2162{2163int*opt_value = opt->value;21642165if(!strcmp(arg,"mbox"))2166*opt_value = PATCH_FORMAT_MBOX;2167else if(!strcmp(arg,"stgit"))2168*opt_value = PATCH_FORMAT_STGIT;2169else if(!strcmp(arg,"stgit-series"))2170*opt_value = PATCH_FORMAT_STGIT_SERIES;2171else if(!strcmp(arg,"hg"))2172*opt_value = PATCH_FORMAT_HG;2173else if(!strcmp(arg,"mboxrd"))2174*opt_value = PATCH_FORMAT_MBOXRD;2175else2176returnerror(_("Invalid value for --patch-format:%s"), arg);2177return0;2178}21792180enum resume_mode {2181 RESUME_FALSE =0,2182 RESUME_APPLY,2183 RESUME_RESOLVED,2184 RESUME_SKIP,2185 RESUME_ABORT2186};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;22072208const char*const usage[] = {2209N_("git am [<options>] [(<mbox> | <Maildir>)...]"),2210N_("git am [<options>] (--continue | --skip | --abort)"),2211 NULL2212};22132214struct option options[] = {2215OPT_BOOL('i',"interactive", &state.interactive,2216N_("run interactively")),2217OPT_HIDDEN_BOOL('b',"binary", &binary,2218N_("historical option -- no-op")),2219OPT_BOOL('3',"3way", &state.threeway,2220N_("allow fall back on 3way merging if needed")),2221OPT__QUIET(&state.quiet,N_("be quiet")),2222OPT_SET_INT('s',"signoff", &state.signoff,2223N_("add a Signed-off-by line to the commit message"),2224 SIGNOFF_EXPLICIT),2225OPT_BOOL('u',"utf8", &state.utf8,2226N_("recode into utf8 (default)")),2227OPT_SET_INT('k',"keep", &state.keep,2228N_("pass -k flag to git-mailinfo"), KEEP_TRUE),2229OPT_SET_INT(0,"keep-non-patch", &state.keep,2230N_("pass -b flag to git-mailinfo"), KEEP_NON_PATCH),2231OPT_BOOL('m',"message-id", &state.message_id,2232N_("pass -m flag to git-mailinfo")),2233{ OPTION_SET_INT,0,"keep-cr", &keep_cr, NULL,2234N_("pass --keep-cr flag to git-mailsplit for mbox format"),2235 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},2236{ OPTION_SET_INT,0,"no-keep-cr", &keep_cr, NULL,2237N_("do not pass --keep-cr flag to git-mailsplit independent of am.keepcr"),2238 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,0},2239OPT_BOOL('c',"scissors", &state.scissors,2240N_("strip everything before a scissors line")),2241OPT_PASSTHRU_ARGV(0,"whitespace", &state.git_apply_opts,N_("action"),2242N_("pass it through git-apply"),22430),2244OPT_PASSTHRU_ARGV(0,"ignore-space-change", &state.git_apply_opts, NULL,2245N_("pass it through git-apply"),2246 PARSE_OPT_NOARG),2247OPT_PASSTHRU_ARGV(0,"ignore-whitespace", &state.git_apply_opts, NULL,2248N_("pass it through git-apply"),2249 PARSE_OPT_NOARG),2250OPT_PASSTHRU_ARGV(0,"directory", &state.git_apply_opts,N_("root"),2251N_("pass it through git-apply"),22520),2253OPT_PASSTHRU_ARGV(0,"exclude", &state.git_apply_opts,N_("path"),2254N_("pass it through git-apply"),22550),2256OPT_PASSTHRU_ARGV(0,"include", &state.git_apply_opts,N_("path"),2257N_("pass it through git-apply"),22580),2259OPT_PASSTHRU_ARGV('C', NULL, &state.git_apply_opts,N_("n"),2260N_("pass it through git-apply"),22610),2262OPT_PASSTHRU_ARGV('p', NULL, &state.git_apply_opts,N_("num"),2263N_("pass it through git-apply"),22640),2265OPT_CALLBACK(0,"patch-format", &patch_format,N_("format"),2266N_("format the patch(es) are in"),2267 parse_opt_patchformat),2268OPT_PASSTHRU_ARGV(0,"reject", &state.git_apply_opts, NULL,2269N_("pass it through git-apply"),2270 PARSE_OPT_NOARG),2271OPT_STRING(0,"resolvemsg", &state.resolvemsg, NULL,2272N_("override error message when patch failure occurs")),2273OPT_CMDMODE(0,"continue", &resume,2274N_("continue applying patches after resolving a conflict"),2275 RESUME_RESOLVED),2276OPT_CMDMODE('r',"resolved", &resume,2277N_("synonyms for --continue"),2278 RESUME_RESOLVED),2279OPT_CMDMODE(0,"skip", &resume,2280N_("skip the current patch"),2281 RESUME_SKIP),2282OPT_CMDMODE(0,"abort", &resume,2283N_("restore the original branch and abort the patching operation."),2284 RESUME_ABORT),2285OPT_BOOL(0,"committer-date-is-author-date",2286&state.committer_date_is_author_date,2287N_("lie about committer date")),2288OPT_BOOL(0,"ignore-date", &state.ignore_date,2289N_("use current timestamp for author date")),2290OPT_RERERE_AUTOUPDATE(&state.allow_rerere_autoupdate),2291{ OPTION_STRING,'S',"gpg-sign", &state.sign_commit,N_("key-id"),2292N_("GPG-sign commits"),2293 PARSE_OPT_OPTARG, NULL, (intptr_t)""},2294OPT_HIDDEN_BOOL(0,"rebasing", &state.rebasing,2295N_("(internal use for git-rebase)")),2296OPT_END()2297};22982299if(argc ==2&& !strcmp(argv[1],"-h"))2300usage_with_options(usage, options);23012302git_config(git_am_config, NULL);23032304am_state_init(&state);23052306 in_progress =am_in_progress(&state);2307if(in_progress)2308am_load(&state);23092310 argc =parse_options(argc, argv, prefix, options, usage,0);23112312if(binary >=0)2313fprintf_ln(stderr,_("The -b/--binary option has been a no-op for long time, and\n"2314"it will be removed. Please do not use it anymore."));23152316/* Ensure a valid committer ident can be constructed */2317git_committer_info(IDENT_STRICT);23182319if(read_index_preload(&the_index, NULL) <0)2320die(_("failed to read the index"));23212322if(in_progress) {2323/*2324 * Catch user error to feed us patches when there is a session2325 * in progress:2326 *2327 * 1. mbox path(s) are provided on the command-line.2328 * 2. stdin is not a tty: the user is trying to feed us a patch2329 * from standard input. This is somewhat unreliable -- stdin2330 * could be /dev/null for example and the caller did not2331 * intend to feed us a patch but wanted to continue2332 * unattended.2333 */2334if(argc || (resume == RESUME_FALSE && !isatty(0)))2335die(_("previous rebase directory%sstill exists but mbox given."),2336 state.dir);23372338if(resume == RESUME_FALSE)2339 resume = RESUME_APPLY;23402341if(state.signoff == SIGNOFF_EXPLICIT)2342am_append_signoff(&state);2343}else{2344struct argv_array paths = ARGV_ARRAY_INIT;2345int i;23462347/*2348 * Handle stray state directory in the independent-run case. In2349 * the --rebasing case, it is up to the caller to take care of2350 * stray directories.2351 */2352if(file_exists(state.dir) && !state.rebasing) {2353if(resume == RESUME_ABORT) {2354am_destroy(&state);2355am_state_release(&state);2356return0;2357}23582359die(_("Stray%sdirectory found.\n"2360"Use\"git am --abort\"to remove it."),2361 state.dir);2362}23632364if(resume)2365die(_("Resolve operation not in progress, we are not resuming."));23662367for(i =0; i < argc; i++) {2368if(is_absolute_path(argv[i]) || !prefix)2369argv_array_push(&paths, argv[i]);2370else2371argv_array_push(&paths,mkpath("%s/%s", prefix, argv[i]));2372}23732374am_setup(&state, patch_format, paths.argv, keep_cr);23752376argv_array_clear(&paths);2377}23782379switch(resume) {2380case RESUME_FALSE:2381am_run(&state,0);2382break;2383case RESUME_APPLY:2384am_run(&state,1);2385break;2386case RESUME_RESOLVED:2387am_resolve(&state);2388break;2389case RESUME_SKIP:2390am_skip(&state);2391break;2392case RESUME_ABORT:2393am_abort(&state);2394break;2395default:2396die("BUG: invalid resume value");2397}23982399am_state_release(&state);24002401return0;2402}