1 /* 2 * $OpenBSD: pch.c,v 1.37 2007/09/02 15:19:33 deraadt Exp $ 3 * $DragonFly: src/usr.bin/patch/pch.c,v 1.6 2008/08/10 23:35:40 joerg Exp $ 4 * $NetBSD: pch.c,v 1.34 2024/07/12 15:48:39 manu Exp $ 5 */ 6 7 /* 8 * patch - a program to apply diffs to original files 9 * 10 * Copyright 1986, Larry Wall 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following condition is met: 14 * 1. Redistributions of source code must retain the above copyright notice, 15 * this condition and the following disclaimer. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY 18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 20 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 23 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 24 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * -C option added in 1998, original code by Marc Espie, based on FreeBSD 30 * behaviour 31 */ 32 33 #include <sys/cdefs.h> 34 __RCSID("$NetBSD: pch.c,v 1.34 2024/07/12 15:48:39 manu Exp $"); 35 36 #include <sys/types.h> 37 #include <sys/stat.h> 38 39 #include <ctype.h> 40 #include <libgen.h> 41 #include <limits.h> 42 #include <stdio.h> 43 #include <stdlib.h> 44 #include <string.h> 45 #include <unistd.h> 46 47 #include "common.h" 48 #include "util.h" 49 #include "pch.h" 50 #include "pathnames.h" 51 52 /* Patch (diff listing) abstract type. */ 53 54 static long p_filesize; /* size of the patch file */ 55 static LINENUM p_first; /* 1st line number */ 56 static LINENUM p_newfirst; /* 1st line number of replacement */ 57 static LINENUM p_ptrn_lines; /* # lines in pattern */ 58 static LINENUM p_repl_lines; /* # lines in replacement text */ 59 static LINENUM p_end = -1; /* last line in hunk */ 60 static LINENUM p_max; /* max allowed value of p_end */ 61 static LINENUM p_context = 3; /* # of context lines */ 62 static LINENUM p_input_line = 0; /* current line # from patch file */ 63 static char **p_line = NULL;/* the text of the hunk */ 64 static ssize_t *p_len = NULL; /* length of each line */ 65 static char *p_char = NULL; /* +, -, and ! */ 66 static int hunkmax = INITHUNKMAX; /* size of above arrays to begin with */ 67 static int p_indent; /* indent to patch */ 68 static LINENUM p_base; /* where to intuit this time */ 69 static LINENUM p_bline; /* line # of p_base */ 70 static LINENUM p_start; /* where intuit found a patch */ 71 static LINENUM p_sline; /* and the line number for it */ 72 static LINENUM p_hunk_beg; /* line number of current hunk */ 73 static LINENUM p_efake = -1; /* end of faked up lines--don't free */ 74 static LINENUM p_bfake = -1; /* beg of faked up lines */ 75 static FILE *pfp = NULL; /* patch file pointer */ 76 static char *bestguess = NULL; /* guess at correct filename */ 77 78 static void grow_hunkmax(void); 79 static int intuit_diff_type(void); 80 static void next_intuit_at(LINENUM, LINENUM); 81 static void skip_to(LINENUM, LINENUM); 82 static int pgetline(char **, size_t *, FILE *); 83 static char *best_name(const struct file_name *, bool); 84 static char *posix_name(const struct file_name *, bool); 85 static size_t num_components(const char *); 86 87 /* 88 * Prepare to look for the next patch in the patch file. 89 */ 90 void 91 re_patch(void) 92 { 93 p_first = 0; 94 p_newfirst = 0; 95 p_ptrn_lines = 0; 96 p_repl_lines = 0; 97 p_end = (LINENUM) - 1; 98 p_max = 0; 99 p_indent = 0; 100 } 101 102 /* 103 * Open the patch file at the beginning of time. 104 */ 105 void 106 open_patch_file(const char *filename) 107 { 108 struct stat filestat; 109 110 if (filename == NULL || *filename == '\0' || strEQ(filename, "-")) { 111 pfp = fopen(TMPPATNAME, "w"); 112 if (pfp == NULL) 113 pfatal("can't create %s", TMPPATNAME); 114 while (getline(&buf, &bufsz, stdin) != -1) 115 fprintf(pfp, "%s", buf); 116 if (ferror(pfp) || fclose(pfp)) 117 pfatal("can't write %s", TMPPATNAME); 118 filename = TMPPATNAME; 119 } 120 pfp = fopen(filename, "r"); 121 if (pfp == NULL) 122 pfatal("patch file %s not found", filename); 123 fstat(fileno(pfp), &filestat); 124 p_filesize = filestat.st_size; 125 next_intuit_at(0L, 1L); /* start at the beginning */ 126 set_hunkmax(); 127 } 128 129 /* 130 * Make sure our dynamically realloced tables are malloced to begin with. 131 */ 132 void 133 set_hunkmax(void) 134 { 135 if (p_line == NULL) 136 p_line = calloc((size_t) hunkmax, sizeof(char *)); 137 if (p_len == NULL) 138 p_len = calloc((size_t) hunkmax, sizeof(ssize_t)); 139 if (p_char == NULL) 140 p_char = calloc((size_t) hunkmax, sizeof(char)); 141 } 142 143 /* 144 * Enlarge the arrays containing the current hunk of patch. 145 */ 146 static void 147 grow_hunkmax(void) 148 { 149 int new_hunkmax; 150 char **new_p_line; 151 ssize_t *new_p_len; 152 char *new_p_char; 153 154 new_hunkmax = hunkmax * 2; 155 156 if (p_line == NULL || p_len == NULL || p_char == NULL) 157 fatal("Internal memory allocation error\n"); 158 159 new_p_line = pch_realloc(p_line, new_hunkmax, sizeof(char *)); 160 if (new_p_line == NULL) 161 free(p_line); 162 163 new_p_len = pch_realloc(p_len, new_hunkmax, sizeof(ssize_t)); 164 if (new_p_len == NULL) 165 free(p_len); 166 167 new_p_char = pch_realloc(p_char, new_hunkmax, sizeof(char)); 168 if (new_p_char == NULL) 169 free(p_char); 170 171 p_char = new_p_char; 172 p_len = new_p_len; 173 p_line = new_p_line; 174 175 if (p_line != NULL && p_len != NULL && p_char != NULL) { 176 hunkmax = new_hunkmax; 177 return; 178 } 179 180 if (!using_plan_a) 181 fatal("out of memory\n"); 182 out_of_mem = true; /* whatever is null will be allocated again */ 183 /* from within plan_a(), of all places */ 184 } 185 186 /* True if the remainder of the patch file contains a diff of some sort. */ 187 188 bool 189 there_is_another_patch(void) 190 { 191 bool exists = false; 192 193 if (p_base != 0L && p_base >= p_filesize) { 194 if (verbose) 195 say("done\n"); 196 return false; 197 } 198 if (verbose) 199 say("Hmm..."); 200 diff_type = intuit_diff_type(); 201 if (!diff_type) { 202 if (p_base != 0L) { 203 if (verbose) 204 say(" Ignoring the trailing garbage.\ndone\n"); 205 } else 206 say(" I can't seem to find a patch in there anywhere.\n"); 207 return false; 208 } 209 if (verbose) 210 say(" %sooks like %s to me...\n", 211 (p_base == 0L ? "L" : "The next patch l"), 212 diff_type == UNI_DIFF ? "a unified diff" : 213 diff_type == CONTEXT_DIFF ? "a context diff" : 214 diff_type == NEW_CONTEXT_DIFF ? "a new-style context diff" : 215 diff_type == NORMAL_DIFF ? "a normal diff" : 216 "an ed script"); 217 if (p_indent && verbose) 218 say("(Patch is indented %d space%s.)\n", p_indent, 219 p_indent == 1 ? "" : "s"); 220 skip_to(p_start, p_sline); 221 while (filearg[0] == NULL) { 222 if (force || batch) { 223 say("No file to patch. Skipping...\n"); 224 filearg[0] = savestr(bestguess); 225 skip_rest_of_patch = true; 226 return true; 227 } 228 ask("File to patch: "); 229 if (*buf != '\n') { 230 free(bestguess); 231 bestguess = savestr(buf); 232 filearg[0] = fetchname(buf, &exists, 0); 233 } 234 if (!exists) { 235 ask("No file found--skip this patch? [n] "); 236 if (*buf != 'y') 237 continue; 238 if (verbose) 239 say("Skipping patch...\n"); 240 free(filearg[0]); 241 filearg[0] = fetchname(bestguess, &exists, 0); 242 skip_rest_of_patch = true; 243 return true; 244 } 245 } 246 return true; 247 } 248 249 /* Determine what kind of diff is in the remaining part of the patch file. */ 250 251 static int 252 intuit_diff_type(void) 253 { 254 long this_line = 0, previous_line; 255 long first_command_line = -1; 256 LINENUM fcl_line = -1; 257 bool last_line_was_command = false, this_is_a_command = false; 258 bool stars_last_line = false, stars_this_line = false; 259 char *s, *t; 260 int indent, retval; 261 struct file_name names[MAX_FILE]; 262 263 memset(names, 0, sizeof(names)); 264 ok_to_create_file = false; 265 fseek(pfp, p_base, SEEK_SET); 266 p_input_line = p_bline - 1; 267 for (;;) { 268 previous_line = this_line; 269 last_line_was_command = this_is_a_command; 270 stars_last_line = stars_this_line; 271 this_line = ftell(pfp); 272 indent = 0; 273 p_input_line++; 274 if (getline(&buf, &bufsz, pfp) == -1) { 275 if (first_command_line >= 0L) { 276 /* nothing but deletes!? */ 277 p_start = first_command_line; 278 p_sline = fcl_line; 279 retval = ED_DIFF; 280 goto scan_exit; 281 } else { 282 p_start = this_line; 283 p_sline = p_input_line; 284 retval = 0; 285 goto scan_exit; 286 } 287 } 288 for (s = buf; *s == ' ' || *s == '\t' || *s == 'X'; s++) { 289 if (*s == '\t') 290 indent += 8 - (indent % 8); 291 else 292 indent++; 293 } 294 for (t = s; isdigit((unsigned char)*t) || *t == ','; t++) 295 ; 296 this_is_a_command = (isdigit((unsigned char)*s) && 297 (*t == 'd' || *t == 'c' || *t == 'a')); 298 if (first_command_line < 0L && this_is_a_command) { 299 first_command_line = this_line; 300 fcl_line = p_input_line; 301 p_indent = indent; /* assume this for now */ 302 } 303 if (!stars_last_line && strnEQ(s, "*** ", 4)) 304 names[OLD_FILE].path = fetchname(s + 4, 305 &names[OLD_FILE].exists, strippath); 306 else if (strnEQ(s, "--- ", 4)) 307 names[NEW_FILE].path = fetchname(s + 4, 308 &names[NEW_FILE].exists, strippath); 309 else if (strnEQ(s, "+++ ", 4)) 310 /* pretend it is the old name */ 311 names[OLD_FILE].path = fetchname(s + 4, 312 &names[OLD_FILE].exists, strippath); 313 else if (strnEQ(s, "Index:", 6)) 314 names[INDEX_FILE].path = fetchname(s + 6, 315 &names[INDEX_FILE].exists, strippath); 316 else if (strnEQ(s, "Prereq:", 7)) { 317 for (t = s + 7; isspace((unsigned char)*t); t++) 318 ; 319 revision = savestr(t); 320 for (t = revision; *t && !isspace((unsigned char)*t); t++) 321 ; 322 *t = '\0'; 323 if (*revision == '\0') { 324 free(revision); 325 revision = NULL; 326 } 327 } 328 if ((!diff_type || diff_type == ED_DIFF) && 329 first_command_line >= 0L && 330 strEQ(s, ".\n")) { 331 p_indent = indent; 332 p_start = first_command_line; 333 p_sline = fcl_line; 334 retval = ED_DIFF; 335 goto scan_exit; 336 } 337 if ((!diff_type || diff_type == UNI_DIFF) && strnEQ(s, "@@ -", 4)) { 338 if (strnEQ(s + 4, "0,0", 3)) 339 ok_to_create_file = true; 340 p_indent = indent; 341 p_start = this_line; 342 p_sline = p_input_line; 343 retval = UNI_DIFF; 344 goto scan_exit; 345 } 346 stars_this_line = strnEQ(s, "********", 8); 347 if ((!diff_type || diff_type == CONTEXT_DIFF) && stars_last_line && 348 strnEQ(s, "*** ", 4)) { 349 if (atol(s + 4) == 0) 350 ok_to_create_file = true; 351 /* 352 * If this is a new context diff the character just 353 * before the newline is a '*'. 354 */ 355 while (*s != '\n') 356 s++; 357 p_indent = indent; 358 p_start = previous_line; 359 p_sline = p_input_line - 1; 360 retval = (*(s - 1) == '*' ? NEW_CONTEXT_DIFF : CONTEXT_DIFF); 361 goto scan_exit; 362 } 363 if ((!diff_type || diff_type == NORMAL_DIFF) && 364 last_line_was_command && 365 (strnEQ(s, "< ", 2) || strnEQ(s, "> ", 2))) { 366 p_start = previous_line; 367 p_sline = p_input_line - 1; 368 p_indent = indent; 369 retval = NORMAL_DIFF; 370 goto scan_exit; 371 } 372 } 373 scan_exit: 374 if (retval == UNI_DIFF) { 375 /* unswap old and new */ 376 struct file_name tmp = names[OLD_FILE]; 377 names[OLD_FILE] = names[NEW_FILE]; 378 names[NEW_FILE] = tmp; 379 } 380 if (filearg[0] == NULL) { 381 if (posix) 382 filearg[0] = posix_name(names, ok_to_create_file); 383 else { 384 /* Ignore the Index: name for context diffs, like GNU */ 385 if (names[OLD_FILE].path != NULL || 386 names[NEW_FILE].path != NULL) { 387 free(names[INDEX_FILE].path); 388 names[INDEX_FILE].path = NULL; 389 } 390 filearg[0] = best_name(names, ok_to_create_file); 391 } 392 } 393 394 free(bestguess); 395 bestguess = NULL; 396 if (filearg[0] != NULL) 397 bestguess = savestr(filearg[0]); 398 else if (!ok_to_create_file) { 399 /* 400 * We don't want to create a new file but we need a 401 * filename to set bestguess. Avoid setting filearg[0] 402 * so the file is not created automatically. 403 */ 404 if (posix) 405 bestguess = posix_name(names, true); 406 else 407 bestguess = best_name(names, true); 408 } 409 free(names[OLD_FILE].path); 410 free(names[NEW_FILE].path); 411 free(names[INDEX_FILE].path); 412 return retval; 413 } 414 415 /* 416 * Remember where this patch ends so we know where to start up again. 417 */ 418 static void 419 next_intuit_at(LINENUM file_pos, LINENUM file_line) 420 { 421 p_base = file_pos; 422 p_bline = file_line; 423 } 424 425 /* 426 * Basically a verbose fseek() to the actual diff listing. 427 */ 428 static void 429 skip_to(LINENUM file_pos, LINENUM file_line) 430 { 431 int ret; 432 433 if (p_base > file_pos) 434 fatal("Internal error: seek %ld>%ld\n", p_base, file_pos); 435 if (verbose && p_base < file_pos) { 436 fseek(pfp, p_base, SEEK_SET); 437 say("The text leading up to this was:\n--------------------------\n"); 438 while (ftell(pfp) < file_pos) { 439 ret = getline(&buf, &bufsz, pfp); 440 if (ret == -1) 441 fatal("Unexpected end of file\n"); 442 say("|%s", buf); 443 } 444 say("--------------------------\n"); 445 } else 446 fseek(pfp, file_pos, SEEK_SET); 447 p_input_line = file_line - 1; 448 } 449 450 /* Make this a function for better debugging. */ 451 __dead static void 452 malformed(void) 453 { 454 fatal("malformed patch at line %ld: %s", p_input_line, buf); 455 /* about as informative as "Syntax error" in C */ 456 } 457 458 static LINENUM 459 getlinenum(const char *s) 460 { 461 LINENUM l = (LINENUM)atol(s); 462 if (l < 0) { 463 l = 0; 464 malformed(); 465 } 466 return l; 467 } 468 469 static LINENUM 470 getskiplinenum(char **p) 471 { 472 char *s = *p; 473 LINENUM l = getlinenum(s); 474 while (isdigit((unsigned char)*s)) 475 s++; 476 *p = s; 477 return l; 478 } 479 480 /* 481 * True if the line has been discarded (i.e., it is a line saying 482 * "\ No newline at end of file".) 483 */ 484 static bool 485 remove_special_line(void) 486 { 487 int c; 488 489 c = fgetc(pfp); 490 if (c == '\\') { 491 do { 492 c = fgetc(pfp); 493 } while (c != EOF && c != '\n'); 494 495 return true; 496 } 497 if (c != EOF) 498 fseek(pfp, -1L, SEEK_CUR); 499 500 return false; 501 } 502 503 /* 504 * True if there is more of the current diff listing to process. 505 */ 506 bool 507 another_hunk(void) 508 { 509 long line_beginning; /* file pos of the current line */ 510 LINENUM repl_beginning; /* index of --- line */ 511 LINENUM fillcnt; /* #lines of missing ptrn or repl */ 512 LINENUM fillsrc; /* index of first line to copy */ 513 LINENUM filldst; /* index of first missing line */ 514 bool ptrn_spaces_eaten; /* ptrn was slightly misformed */ 515 bool repl_could_be_missing; /* no + or ! lines in this hunk */ 516 bool repl_missing; /* we are now backtracking */ 517 long repl_backtrack_position; /* file pos of first repl line */ 518 LINENUM repl_patch_line; /* input line number for same */ 519 LINENUM ptrn_copiable; /* # of copiable lines in ptrn */ 520 char *s; 521 int context = 0; 522 int ret; 523 524 while (p_end >= 0) { 525 if (p_end == p_efake) 526 p_end = p_bfake; /* don't free twice */ 527 else 528 free(p_line[p_end]); 529 p_end--; 530 } 531 p_efake = -1; 532 533 p_max = hunkmax; /* gets reduced when --- found */ 534 if (diff_type == CONTEXT_DIFF || diff_type == NEW_CONTEXT_DIFF) { 535 line_beginning = ftell(pfp); 536 repl_beginning = 0; 537 fillcnt = 0; 538 fillsrc = 0; 539 filldst = 0; 540 ptrn_spaces_eaten = false; 541 repl_could_be_missing = true; 542 repl_missing = false; 543 repl_backtrack_position = 0; 544 repl_patch_line = 0; 545 ptrn_copiable = 0; 546 547 ret = pgetline(&buf, &bufsz, pfp); 548 p_input_line++; 549 if (ret == -1 || strnNE(buf, "********", 8)) { 550 next_intuit_at(line_beginning, p_input_line); 551 return false; 552 } 553 p_context = 100; 554 p_hunk_beg = p_input_line + 1; 555 while (p_end < p_max) { 556 // line_beginning = ftell(pfp); 557 ret = pgetline(&buf, &bufsz, pfp); 558 p_input_line++; 559 if (ret == -1) { 560 if (repl_beginning && repl_could_be_missing) { 561 repl_missing = true; 562 goto hunk_done; 563 } 564 fatal("unexpected end of file in patch\n"); 565 } 566 p_end++; 567 if (p_end >= hunkmax) 568 fatal("Internal error: hunk larger than hunk " 569 "buffer size"); 570 p_char[p_end] = *buf; 571 p_line[p_end] = NULL; 572 switch (*buf) { 573 case '*': 574 if (strnEQ(buf, "********", 8)) { 575 if (repl_beginning && repl_could_be_missing) { 576 repl_missing = true; 577 goto hunk_done; 578 } else 579 fatal("unexpected end of hunk " 580 "at line %ld\n", 581 p_input_line); 582 } 583 if (p_end != 0) { 584 if (repl_beginning && repl_could_be_missing) { 585 repl_missing = true; 586 goto hunk_done; 587 } 588 fatal("unexpected *** at line %ld: %s", 589 p_input_line, buf); 590 } 591 context = 0; 592 p_line[p_end] = savestr(buf); 593 if (out_of_mem) { 594 p_end--; 595 return false; 596 } 597 for (s = buf; *s && !isdigit((unsigned char)*s); s++) 598 ; 599 if (!*s) 600 malformed(); 601 if (strnEQ(s, "0,0", 3)) 602 memmove(s, s + 2, strlen(s + 2) + 1); 603 p_first = getskiplinenum(&s); 604 if (*s == ',') { 605 for (; *s && !isdigit((unsigned char)*s); s++) 606 ; 607 if (!*s) 608 malformed(); 609 p_ptrn_lines = (getlinenum(s)) - p_first + 1; 610 if (p_ptrn_lines < 0) 611 malformed(); 612 } else if (p_first) 613 p_ptrn_lines = 1; 614 else { 615 p_ptrn_lines = 0; 616 p_first = 1; 617 } 618 if (p_first >= LINENUM_MAX - p_ptrn_lines || 619 p_ptrn_lines >= LINENUM_MAX - 6) 620 malformed(); 621 622 /* we need this much at least */ 623 p_max = p_ptrn_lines + 6; 624 while (p_max >= hunkmax) 625 grow_hunkmax(); 626 p_max = hunkmax; 627 break; 628 case '-': 629 if (buf[1] == '-') { 630 if (repl_beginning || 631 (p_end != p_ptrn_lines + 1 + 632 (p_char[p_end - 1] == '\n'))) { 633 if (p_end == 1) { 634 /* 635 * `old' lines were omitted; 636 * set up to fill them in 637 * from 'new' context lines. 638 */ 639 p_end = p_ptrn_lines + 1; 640 fillsrc = p_end + 1; 641 filldst = 1; 642 fillcnt = p_ptrn_lines; 643 } else { 644 if (repl_beginning) { 645 if (repl_could_be_missing) { 646 repl_missing = true; 647 goto hunk_done; 648 } 649 fatal("duplicate \"---\" at line %ld--check line numbers at line %ld\n", 650 p_input_line, p_hunk_beg + repl_beginning); 651 } else { 652 fatal("%s \"---\" at line %ld--check line numbers at line %ld\n", 653 (p_end <= p_ptrn_lines 654 ? "Premature" 655 : "Overdue"), 656 p_input_line, p_hunk_beg); 657 } 658 } 659 } 660 repl_beginning = p_end; 661 repl_backtrack_position = ftell(pfp); 662 repl_patch_line = p_input_line; 663 p_line[p_end] = savestr(buf); 664 if (out_of_mem) { 665 p_end--; 666 return false; 667 } 668 p_char[p_end] = '='; 669 for (s = buf; *s && !isdigit((unsigned char)*s); s++) 670 ; 671 if (!*s) 672 malformed(); 673 p_newfirst = getskiplinenum(&s); 674 if (*s == ',') { 675 for (; *s && !isdigit((unsigned char)*s); s++) 676 ; 677 if (!*s) 678 malformed(); 679 p_repl_lines = (getlinenum(s)) - 680 p_newfirst + 1; 681 if (p_repl_lines < 0) 682 malformed(); 683 } else if (p_newfirst) 684 p_repl_lines = 1; 685 else { 686 p_repl_lines = 0; 687 p_newfirst = 1; 688 } 689 if (p_newfirst >= LINENUM_MAX - p_repl_lines || 690 p_repl_lines >= LINENUM_MAX - p_end) 691 malformed(); 692 p_max = p_repl_lines + p_end; 693 if (p_max > MAXHUNKSIZE) 694 fatal("hunk too large (%ld lines) at line %ld: %s", 695 p_max, p_input_line, buf); 696 while (p_max >= hunkmax) 697 grow_hunkmax(); 698 if (p_repl_lines != ptrn_copiable && 699 (p_context != 0 || p_repl_lines != 1)) 700 repl_could_be_missing = false; 701 break; 702 } 703 goto change_line; 704 case '+': 705 case '!': 706 repl_could_be_missing = false; 707 change_line: 708 if (buf[1] == '\n' && canonicalize) 709 strlcpy(buf + 1, " \n", bufsz - 1); 710 if (!isspace((unsigned char)buf[1]) && buf[1] != '>' && 711 buf[1] != '<' && 712 repl_beginning && repl_could_be_missing) { 713 repl_missing = true; 714 goto hunk_done; 715 } 716 if (context >= 0) { 717 if (context < p_context) 718 p_context = context; 719 context = -1000; 720 } 721 p_line[p_end] = savestr(buf + 2); 722 if (out_of_mem) { 723 p_end--; 724 return false; 725 } 726 if (p_end == p_ptrn_lines) { 727 if (remove_special_line()) { 728 int len; 729 730 len = strlen(p_line[p_end]) - 1; 731 (p_line[p_end])[len] = 0; 732 } 733 } 734 break; 735 case '\t': 736 case '\n': /* assume the 2 spaces got eaten */ 737 if (repl_beginning && repl_could_be_missing && 738 (!ptrn_spaces_eaten || 739 diff_type == NEW_CONTEXT_DIFF)) { 740 repl_missing = true; 741 goto hunk_done; 742 } 743 p_line[p_end] = savestr(buf); 744 if (out_of_mem) { 745 p_end--; 746 return false; 747 } 748 if (p_end != p_ptrn_lines + 1) { 749 ptrn_spaces_eaten |= (repl_beginning != 0); 750 context++; 751 if (!repl_beginning) 752 ptrn_copiable++; 753 p_char[p_end] = ' '; 754 } 755 break; 756 case ' ': 757 if (!isspace((unsigned char)buf[1]) && 758 repl_beginning && repl_could_be_missing) { 759 repl_missing = true; 760 goto hunk_done; 761 } 762 context++; 763 if (!repl_beginning) 764 ptrn_copiable++; 765 p_line[p_end] = savestr(buf + 2); 766 if (out_of_mem) { 767 p_end--; 768 return false; 769 } 770 break; 771 default: 772 if (repl_beginning && repl_could_be_missing) { 773 repl_missing = true; 774 goto hunk_done; 775 } 776 malformed(); 777 } 778 /* set up p_len for strncmp() so we don't have to */ 779 /* assume null termination */ 780 if (p_line[p_end]) 781 p_len[p_end] = strlen(p_line[p_end]); 782 else 783 p_len[p_end] = 0; 784 } 785 786 hunk_done: 787 if (p_end >= 0 && !repl_beginning) 788 fatal("no --- found in patch at line %ld\n", pch_hunk_beg()); 789 790 if (repl_missing) { 791 792 /* reset state back to just after --- */ 793 p_input_line = repl_patch_line; 794 for (p_end--; p_end > repl_beginning; p_end--) 795 free(p_line[p_end]); 796 fseek(pfp, repl_backtrack_position, SEEK_SET); 797 798 /* redundant 'new' context lines were omitted - set */ 799 /* up to fill them in from the old file context */ 800 if (!p_context && p_repl_lines == 1) { 801 p_repl_lines = 0; 802 p_max--; 803 } 804 fillsrc = 1; 805 filldst = repl_beginning + 1; 806 fillcnt = p_repl_lines; 807 p_end = p_max; 808 } else if (!p_context && fillcnt == 1) { 809 /* the first hunk was a null hunk with no context */ 810 /* and we were expecting one line -- fix it up. */ 811 while (filldst < p_end) { 812 p_line[filldst] = p_line[filldst + 1]; 813 p_char[filldst] = p_char[filldst + 1]; 814 p_len[filldst] = p_len[filldst + 1]; 815 filldst++; 816 } 817 #if 0 818 repl_beginning--; /* this doesn't need to be fixed */ 819 #endif 820 p_end--; 821 p_first++; /* do append rather than insert */ 822 fillcnt = 0; 823 p_ptrn_lines = 0; 824 } 825 if (diff_type == CONTEXT_DIFF && 826 (fillcnt || (p_first > 1 && ptrn_copiable > 2 * p_context))) { 827 if (verbose) 828 say("%s\n%s\n%s\n", 829 "(Fascinating--this is really a new-style context diff but without", 830 "the telltale extra asterisks on the *** line that usually indicate", 831 "the new style...)"); 832 diff_type = NEW_CONTEXT_DIFF; 833 } 834 /* if there were omitted context lines, fill them in now */ 835 if (fillcnt) { 836 p_bfake = filldst; /* remember where not to free() */ 837 p_efake = filldst + fillcnt - 1; 838 while (fillcnt-- > 0) { 839 while (fillsrc <= p_end && p_char[fillsrc] != ' ') 840 fillsrc++; 841 if (fillsrc > p_end) 842 fatal("replacement text or line numbers mangled in hunk at line %ld\n", 843 p_hunk_beg); 844 p_line[filldst] = p_line[fillsrc]; 845 p_char[filldst] = p_char[fillsrc]; 846 p_len[filldst] = p_len[fillsrc]; 847 fillsrc++; 848 filldst++; 849 } 850 while (fillsrc <= p_end && fillsrc != repl_beginning && 851 p_char[fillsrc] != ' ') 852 fillsrc++; 853 #ifdef DEBUGGING 854 if (debug & 64) 855 printf("fillsrc %ld, filldst %ld, rb %ld, e+1 %ld\n", 856 fillsrc, filldst, repl_beginning, p_end + 1); 857 #endif 858 if (fillsrc != p_end + 1 && fillsrc != repl_beginning) 859 malformed(); 860 if (filldst != p_end + 1 && filldst != repl_beginning) 861 malformed(); 862 } 863 if (p_line[p_end] != NULL) { 864 if (remove_special_line()) { 865 p_len[p_end] -= 1; 866 (p_line[p_end])[p_len[p_end]] = 0; 867 } 868 } 869 } else if (diff_type == UNI_DIFF) { 870 LINENUM fillold; /* index of old lines */ 871 LINENUM fillnew; /* index of new lines */ 872 char ch; 873 874 line_beginning = ftell(pfp); /* file pos of the current line */ 875 ret = pgetline(&buf, &bufsz, pfp); 876 p_input_line++; 877 if (ret == -1 || strnNE(buf, "@@ -", 4)) { 878 next_intuit_at(line_beginning, p_input_line); 879 return false; 880 } 881 s = buf + 4; 882 if (!*s) 883 malformed(); 884 p_first = getskiplinenum(&s); 885 if (*s == ',') { 886 s++; 887 p_ptrn_lines = getskiplinenum(&s); 888 } else 889 p_ptrn_lines = 1; 890 if (p_first >= LINENUM_MAX - p_ptrn_lines) 891 malformed(); 892 if (*s == ' ') 893 s++; 894 if (*s != '+' || !*++s) 895 malformed(); 896 p_newfirst = getskiplinenum(&s); 897 if (*s == ',') { 898 s++; 899 p_repl_lines = getskiplinenum(&s); 900 } else 901 p_repl_lines = 1; 902 if (*s == ' ') 903 s++; 904 if (*s != '@') 905 malformed(); 906 if (p_first >= LINENUM_MAX - p_ptrn_lines || 907 p_newfirst > LINENUM_MAX - p_repl_lines || 908 p_ptrn_lines >= LINENUM_MAX - p_repl_lines - 1) 909 malformed(); 910 if (!p_ptrn_lines) 911 p_first++; /* do append rather than insert */ 912 p_max = p_ptrn_lines + p_repl_lines + 1; 913 while (p_max >= hunkmax) 914 grow_hunkmax(); 915 fillold = 1; 916 fillnew = fillold + p_ptrn_lines; 917 p_end = fillnew + p_repl_lines; 918 snprintf(buf, bufsz, "*** %ld,%ld ****\n", p_first, 919 p_first + p_ptrn_lines - 1); 920 p_line[0] = savestr(buf); 921 if (out_of_mem) { 922 p_end = -1; 923 return false; 924 } 925 p_char[0] = '*'; 926 snprintf(buf, bufsz, "--- %ld,%ld ----\n", p_newfirst, 927 p_newfirst + p_repl_lines - 1); 928 p_line[fillnew] = savestr(buf); 929 if (out_of_mem) { 930 p_end = 0; 931 return false; 932 } 933 p_char[fillnew++] = '='; 934 p_context = 100; 935 context = 0; 936 p_hunk_beg = p_input_line + 1; 937 while (fillold <= p_ptrn_lines || fillnew <= p_end) { 938 // line_beginning = ftell(pfp); 939 ret = pgetline(&buf, &bufsz, pfp); 940 p_input_line++; 941 if (ret == -1) { 942 if (p_max - fillnew < 3) { 943 /* assume blank lines got chopped */ 944 strlcpy(buf, " \n", bufsz); 945 } else { 946 fatal("unexpected end of file in patch\n"); 947 } 948 } 949 if (*buf == '\t' || *buf == '\n') { 950 ch = ' '; /* assume the space got eaten */ 951 s = savestr(buf); 952 } else { 953 ch = *buf; 954 s = savestr(buf + 1); 955 } 956 if (out_of_mem) { 957 while (--fillnew > p_ptrn_lines) 958 free(p_line[fillnew]); 959 p_end = fillold - 1; 960 return false; 961 } 962 switch (ch) { 963 case '-': 964 if (fillold > p_ptrn_lines) { 965 free(s); 966 p_end = fillnew - 1; 967 malformed(); 968 } 969 p_char[fillold] = ch; 970 p_line[fillold] = s; 971 p_len[fillold++] = strlen(s); 972 if (fillold > p_ptrn_lines) { 973 if (remove_special_line()) { 974 p_len[fillold - 1] -= 1; 975 s[p_len[fillold - 1]] = 0; 976 } 977 } 978 break; 979 case '=': 980 ch = ' '; 981 /* FALL THROUGH */ 982 case ' ': 983 if (fillold > p_ptrn_lines) { 984 free(s); 985 while (--fillnew > p_ptrn_lines) 986 free(p_line[fillnew]); 987 p_end = fillold - 1; 988 malformed(); 989 } 990 context++; 991 p_char[fillold] = ch; 992 p_line[fillold] = s; 993 p_len[fillold++] = strlen(s); 994 s = savestr(s); 995 if (out_of_mem) { 996 while (--fillnew > p_ptrn_lines) 997 free(p_line[fillnew]); 998 p_end = fillold - 1; 999 return false; 1000 } 1001 if (fillold > p_ptrn_lines) { 1002 if (remove_special_line()) { 1003 p_len[fillold - 1] -= 1; 1004 s[p_len[fillold - 1]] = 0; 1005 } 1006 } 1007 /* FALL THROUGH */ 1008 case '+': 1009 if (fillnew > p_end) { 1010 free(s); 1011 while (--fillnew > p_ptrn_lines) 1012 free(p_line[fillnew]); 1013 p_end = fillold - 1; 1014 malformed(); 1015 } 1016 p_char[fillnew] = ch; 1017 p_line[fillnew] = s; 1018 p_len[fillnew++] = strlen(s); 1019 if (fillold > p_ptrn_lines) { 1020 if (remove_special_line()) { 1021 p_len[fillnew - 1] -= 1; 1022 s[p_len[fillnew - 1]] = 0; 1023 } 1024 } 1025 break; 1026 default: 1027 p_end = fillnew; 1028 malformed(); 1029 } 1030 if (ch != ' ' && context > 0) { 1031 if (context < p_context) 1032 p_context = context; 1033 context = -1000; 1034 } 1035 } /* while */ 1036 } else { /* normal diff--fake it up */ 1037 char hunk_type; 1038 int i; 1039 LINENUM min, max; 1040 1041 line_beginning = ftell(pfp); 1042 p_context = 0; 1043 ret = pgetline(&buf, &bufsz, pfp); 1044 p_input_line++; 1045 if (ret == -1 || !isdigit((unsigned char)*buf)) { 1046 next_intuit_at(line_beginning, p_input_line); 1047 return false; 1048 } 1049 s = buf; 1050 p_first = getskiplinenum(&s); 1051 if (*s == ',') { 1052 s++; 1053 p_ptrn_lines = getskiplinenum(&s) - p_first + 1; 1054 } else 1055 p_ptrn_lines = (*s != 'a'); 1056 if (p_first >= LINENUM_MAX - p_ptrn_lines) 1057 malformed(); 1058 hunk_type = *s++; 1059 if (hunk_type == 'a') 1060 p_first++; /* do append rather than insert */ 1061 min = getskiplinenum(&s); 1062 if (*s == ',') 1063 max = getlinenum(++s); 1064 else 1065 max = min; 1066 if (min < 0 || min > max || max - min == LINENUM_MAX) 1067 malformed(); 1068 if (hunk_type == 'd') 1069 min++; 1070 p_end = p_ptrn_lines + 1 + max - min + 1; 1071 p_newfirst = min; 1072 p_repl_lines = max - min + 1; 1073 if (p_newfirst > LINENUM_MAX - p_repl_lines || 1074 p_ptrn_lines >= LINENUM_MAX - p_repl_lines - 1) 1075 malformed(); 1076 p_end = p_ptrn_lines + p_repl_lines + 1; 1077 if (p_end > MAXHUNKSIZE) 1078 fatal("hunk too large (%ld lines) at line %ld: %s", 1079 p_end, p_input_line, buf); 1080 while (p_end >= hunkmax) 1081 grow_hunkmax(); 1082 snprintf(buf, bufsz, "*** %ld,%ld\n", p_first, 1083 p_first + p_ptrn_lines - 1); 1084 p_line[0] = savestr(buf); 1085 if (out_of_mem) { 1086 p_end = -1; 1087 return false; 1088 } 1089 p_char[0] = '*'; 1090 for (i = 1; i <= p_ptrn_lines; i++) { 1091 ret = pgetline(&buf, &bufsz, pfp); 1092 p_input_line++; 1093 if (ret == -1) 1094 fatal("unexpected end of file in patch at line %ld\n", 1095 p_input_line); 1096 if (*buf != '<') 1097 fatal("< expected at line %ld of patch\n", 1098 p_input_line); 1099 p_line[i] = savestr(buf + 2); 1100 if (out_of_mem) { 1101 p_end = i - 1; 1102 return false; 1103 } 1104 p_len[i] = strlen(p_line[i]); 1105 p_char[i] = '-'; 1106 } 1107 1108 if (remove_special_line()) { 1109 p_len[i - 1] -= 1; 1110 (p_line[i - 1])[p_len[i - 1]] = 0; 1111 } 1112 if (hunk_type == 'c') { 1113 ret = pgetline(&buf, &bufsz, pfp); 1114 p_input_line++; 1115 if (ret == -1) 1116 fatal("unexpected end of file in patch at line %ld\n", 1117 p_input_line); 1118 if (*buf != '-') 1119 fatal("--- expected at line %ld of patch\n", 1120 p_input_line); 1121 } 1122 snprintf(buf, bufsz, "--- %ld,%ld\n", min, max); 1123 p_line[i] = savestr(buf); 1124 if (out_of_mem) { 1125 p_end = i - 1; 1126 return false; 1127 } 1128 p_char[i] = '='; 1129 for (i++; i <= p_end; i++) { 1130 ret = pgetline(&buf, &bufsz, pfp); 1131 p_input_line++; 1132 if (ret == -1) 1133 fatal("unexpected end of file in patch at line %ld\n", 1134 p_input_line); 1135 if (*buf != '>') 1136 fatal("> expected at line %ld of patch\n", 1137 p_input_line); 1138 p_line[i] = savestr(buf + 2); 1139 if (out_of_mem) { 1140 p_end = i - 1; 1141 return false; 1142 } 1143 p_len[i] = strlen(p_line[i]); 1144 p_char[i] = '+'; 1145 } 1146 1147 if (remove_special_line()) { 1148 p_len[i - 1] -= 1; 1149 (p_line[i - 1])[p_len[i - 1]] = 0; 1150 } 1151 } 1152 if (reverse) /* backwards patch? */ 1153 if (!pch_swap()) 1154 say("Not enough memory to swap next hunk!\n"); 1155 #ifdef DEBUGGING 1156 if (debug & 2) { 1157 int i; 1158 char special; 1159 1160 for (i = 0; i <= p_end; i++) { 1161 if (i == p_ptrn_lines) 1162 special = '^'; 1163 else 1164 special = ' '; 1165 fprintf(stderr, "%3d %c %c %s", i, p_char[i], 1166 special, p_line[i]); 1167 fflush(stderr); 1168 } 1169 } 1170 #endif 1171 if (p_end + 1 < hunkmax)/* paranoia reigns supreme... */ 1172 p_char[p_end + 1] = '^'; /* add a stopper for apply_hunk */ 1173 return true; 1174 } 1175 1176 /* 1177 * Input a line from the patch file, worrying about indentation. 1178 */ 1179 int 1180 pgetline(char **bf, size_t *sz, FILE *fp) 1181 { 1182 char *s; 1183 int indent = 0; 1184 int ret; 1185 1186 ret = getline(bf, sz, fp); 1187 1188 if (p_indent && ret != -1) { 1189 for (s = buf; 1190 indent < p_indent && (*s == ' ' || *s == '\t' || *s == 'X'); 1191 s++) { 1192 if (*s == '\t') 1193 indent += 8 - (indent % 7); 1194 else 1195 indent++; 1196 } 1197 if (buf != s && strlcpy(buf, s, bufsz) >= bufsz) 1198 fatal("buffer too small in pgetline()\n"); 1199 } 1200 return ret; 1201 } 1202 1203 /* 1204 * Reverse the old and new portions of the current hunk. 1205 */ 1206 bool 1207 pch_swap(void) 1208 { 1209 char **tp_line; /* the text of the hunk */ 1210 ssize_t *tp_len; /* length of each line */ 1211 char *tp_char; /* +, -, and ! */ 1212 LINENUM i; 1213 LINENUM n; 1214 bool blankline = false; 1215 char *s; 1216 1217 i = p_first; 1218 p_first = p_newfirst; 1219 p_newfirst = i; 1220 1221 /* make a scratch copy */ 1222 1223 tp_line = p_line; 1224 tp_len = p_len; 1225 tp_char = p_char; 1226 p_line = NULL; /* force set_hunkmax to allocate again */ 1227 p_len = NULL; 1228 p_char = NULL; 1229 set_hunkmax(); 1230 if (p_line == NULL || p_len == NULL || p_char == NULL) { 1231 1232 free(p_line); 1233 p_line = tp_line; 1234 free(p_len); 1235 p_len = tp_len; 1236 free(p_char); 1237 p_char = tp_char; 1238 return false; /* not enough memory to swap hunk! */ 1239 } 1240 /* now turn the new into the old */ 1241 1242 i = p_ptrn_lines + 1; 1243 if (tp_char[i] == '\n') { /* account for possible blank line */ 1244 blankline = true; 1245 i++; 1246 } 1247 if (p_efake >= 0) { /* fix non-freeable ptr range */ 1248 if (p_efake <= i) 1249 n = p_end - i + 1; 1250 else 1251 n = -i; 1252 p_efake += n; 1253 p_bfake += n; 1254 } 1255 for (n = 0; i <= p_end; i++, n++) { 1256 p_line[n] = tp_line[i]; 1257 p_char[n] = tp_char[i]; 1258 if (p_char[n] == '+') 1259 p_char[n] = '-'; 1260 p_len[n] = tp_len[i]; 1261 } 1262 if (blankline) { 1263 i = p_ptrn_lines + 1; 1264 p_line[n] = tp_line[i]; 1265 p_char[n] = tp_char[i]; 1266 p_len[n] = tp_len[i]; 1267 n++; 1268 } 1269 if (p_char[0] != '=') 1270 fatal("Malformed patch at line %ld: expected '=' found '%c'\n", 1271 p_input_line, p_char[0]); 1272 p_char[0] = '*'; 1273 for (s = p_line[0]; *s; s++) 1274 if (*s == '-') 1275 *s = '*'; 1276 1277 /* now turn the old into the new */ 1278 1279 if (p_char[0] != '*') 1280 fatal("Malformed patch at line %ld: expected '*' found '%c'\n", 1281 p_input_line, p_char[0]); 1282 tp_char[0] = '='; 1283 for (s = tp_line[0]; *s; s++) 1284 if (*s == '*') 1285 *s = '-'; 1286 for (i = 0; n <= p_end; i++, n++) { 1287 p_line[n] = tp_line[i]; 1288 p_char[n] = tp_char[i]; 1289 if (p_char[n] == '-') 1290 p_char[n] = '+'; 1291 p_len[n] = tp_len[i]; 1292 } 1293 1294 if (i != p_ptrn_lines + 1) 1295 fatal("Malformed patch at line %ld: expected %ld lines, " 1296 "got %ld\n", 1297 p_input_line, p_ptrn_lines + 1, i); 1298 1299 i = p_ptrn_lines; 1300 p_ptrn_lines = p_repl_lines; 1301 p_repl_lines = i; 1302 1303 free(tp_line); 1304 free(tp_len); 1305 free(tp_char); 1306 1307 return true; 1308 } 1309 1310 /* 1311 * Return the specified line position in the old file of the old context. 1312 */ 1313 LINENUM 1314 pch_first(void) 1315 { 1316 return p_first; 1317 } 1318 1319 /* 1320 * Return the number of lines of old context. 1321 */ 1322 LINENUM 1323 pch_ptrn_lines(void) 1324 { 1325 return p_ptrn_lines; 1326 } 1327 1328 /* 1329 * Return the probable line position in the new file of the first line. 1330 */ 1331 LINENUM 1332 pch_newfirst(void) 1333 { 1334 return p_newfirst; 1335 } 1336 1337 /* 1338 * Return the number of lines in the replacement text including context. 1339 */ 1340 LINENUM 1341 pch_repl_lines(void) 1342 { 1343 return p_repl_lines; 1344 } 1345 1346 /* 1347 * Return the number of lines in the whole hunk. 1348 */ 1349 LINENUM 1350 pch_end(void) 1351 { 1352 return p_end; 1353 } 1354 1355 /* 1356 * Return the number of context lines before the first changed line. 1357 */ 1358 LINENUM 1359 pch_context(void) 1360 { 1361 return p_context; 1362 } 1363 1364 /* 1365 * Return the length of a particular patch line. 1366 */ 1367 ssize_t 1368 pch_line_len(LINENUM line) 1369 { 1370 return p_len[line]; 1371 } 1372 1373 /* 1374 * Return the control character (+, -, *, !, etc) for a patch line. 1375 */ 1376 char 1377 pch_char(LINENUM line) 1378 { 1379 return p_char[line]; 1380 } 1381 1382 /* 1383 * Return a pointer to a particular patch line. 1384 */ 1385 char * 1386 pfetch(LINENUM line) 1387 { 1388 return p_line[line]; 1389 } 1390 1391 /* 1392 * Return where in the patch file this hunk began, for error messages. 1393 */ 1394 LINENUM 1395 pch_hunk_beg(void) 1396 { 1397 return p_hunk_beg; 1398 } 1399 1400 /* 1401 * Apply an ed script by feeding ed itself. 1402 */ 1403 void 1404 do_ed_script(void) 1405 { 1406 char *t; 1407 long beginning_of_this_line; 1408 FILE *pipefp = NULL; 1409 int continuation; 1410 1411 if (!skip_rest_of_patch) { 1412 if (copy_file(filearg[0], TMPOUTNAME) < 0) { 1413 unlink(TMPOUTNAME); 1414 fatal("can't create temp file %s", TMPOUTNAME); 1415 } 1416 snprintf(buf, bufsz, "%s -S%s %s", _PATH_ED, 1417 verbose ? "" : "s", TMPOUTNAME); 1418 pipefp = popen(buf, "w"); 1419 } 1420 for (;;) { 1421 beginning_of_this_line = ftell(pfp); 1422 if (pgetline(&buf, &bufsz, pfp) == -1) { 1423 next_intuit_at(beginning_of_this_line, p_input_line); 1424 break; 1425 } 1426 p_input_line++; 1427 for (t = buf; isdigit((unsigned char)*t) || *t == ','; t++) 1428 ; 1429 /* POSIX defines allowed commands as {a,c,d,i,s} */ 1430 if (isdigit((unsigned char)*buf) && (*t == 'a' || *t == 'c' || 1431 *t == 'd' || *t == 'i' || *t == 's')) { 1432 if (pipefp != NULL) 1433 fprintf(pipefp, "%s", buf); 1434 if (*t == 's') { 1435 for (;;) { 1436 continuation = 0; 1437 t = strchr(buf, '\0') - 1; 1438 while (--t >= buf && *t == '\\') 1439 continuation = !continuation; 1440 if (!continuation || 1441 pgetline(&buf, &bufsz, pfp) == -1) 1442 break; 1443 if (pipefp != NULL) 1444 fprintf(pipefp, "%s", buf); 1445 } 1446 } else if (*t != 'd') { 1447 while (pgetline(&buf, &bufsz, pfp) != -1) { 1448 p_input_line++; 1449 if (pipefp != NULL) 1450 fprintf(pipefp, "%s", buf); 1451 if (strEQ(buf, ".\n")) 1452 break; 1453 } 1454 } 1455 } else { 1456 next_intuit_at(beginning_of_this_line, p_input_line); 1457 break; 1458 } 1459 } 1460 if (pipefp == NULL) 1461 return; 1462 fprintf(pipefp, "w\n"); 1463 fprintf(pipefp, "q\n"); 1464 fflush(pipefp); 1465 pclose(pipefp); 1466 ignore_signals(); 1467 if (!check_only) { 1468 if (move_file(TMPOUTNAME, outname) < 0) { 1469 toutkeep = true; 1470 chmod(TMPOUTNAME, filemode); 1471 } else 1472 chmod(outname, filemode); 1473 } 1474 set_signals(1); 1475 } 1476 1477 /* 1478 * Choose the name of the file to be patched based on POSIX rules. 1479 * NOTE: the POSIX rules are amazingly stupid and we only follow them 1480 * if the user specified --posix or set POSIXLY_CORRECT. 1481 */ 1482 static char * 1483 posix_name(const struct file_name *names, bool assume_exists) 1484 { 1485 char *path = NULL; 1486 int i; 1487 1488 /* 1489 * POSIX states that the filename will be chosen from one 1490 * of the old, new and index names (in that order) if 1491 * the file exists relative to CWD after -p stripping. 1492 */ 1493 for (i = 0; i < MAX_FILE; i++) { 1494 if (names[i].path != NULL && names[i].exists) { 1495 path = names[i].path; 1496 break; 1497 } 1498 } 1499 if (path == NULL && !assume_exists) { 1500 /* 1501 * No files found, look for something we can checkout from 1502 * RCS/SCCS dirs. Same order as above. 1503 */ 1504 for (i = 0; i < MAX_FILE; i++) { 1505 if (names[i].path != NULL && 1506 (path = checked_in(names[i].path)) != NULL) 1507 break; 1508 } 1509 /* 1510 * Still no match? Check to see if the diff could be creating 1511 * a new file. 1512 */ 1513 if (path == NULL && ok_to_create_file && 1514 names[NEW_FILE].path != NULL) 1515 path = names[NEW_FILE].path; 1516 } 1517 1518 return path ? savestr(path) : NULL; 1519 } 1520 1521 /* 1522 * Choose the name of the file to be patched based the "best" one 1523 * available. 1524 */ 1525 static char * 1526 best_name(const struct file_name *names, bool assume_exists) 1527 { 1528 size_t min_components, min_baselen, min_len, tmp; 1529 char *best = NULL; 1530 int i; 1531 1532 /* 1533 * The "best" name is the one with the fewest number of path 1534 * components, the shortest basename length, and the shortest 1535 * overall length (in that order). We only use the Index: file 1536 * if neither of the old or new files could be intuited from 1537 * the diff header. 1538 */ 1539 min_components = min_baselen = min_len = SIZE_MAX; 1540 for (i = INDEX_FILE; i >= OLD_FILE; i--) { 1541 if (names[i].path == NULL || 1542 (!names[i].exists && !assume_exists)) 1543 continue; 1544 if ((tmp = num_components(names[i].path)) > min_components) 1545 continue; 1546 min_components = tmp; 1547 if ((tmp = strlen(basename(names[i].path))) > min_baselen) 1548 continue; 1549 min_baselen = tmp; 1550 if ((tmp = strlen(names[i].path)) > min_len) 1551 continue; 1552 min_len = tmp; 1553 best = names[i].path; 1554 } 1555 if (best == NULL) { 1556 /* 1557 * No files found, look for something we can checkout from 1558 * RCS/SCCS dirs. Logic is identical to that above... 1559 */ 1560 min_components = min_baselen = min_len = SIZE_MAX; 1561 for (i = INDEX_FILE; i >= OLD_FILE; i--) { 1562 if (names[i].path == NULL || 1563 checked_in(names[i].path) == NULL) 1564 continue; 1565 if ((tmp = num_components(names[i].path)) > min_components) 1566 continue; 1567 min_components = tmp; 1568 if ((tmp = strlen(basename(names[i].path))) > min_baselen) 1569 continue; 1570 min_baselen = tmp; 1571 if ((tmp = strlen(names[i].path)) > min_len) 1572 continue; 1573 min_len = tmp; 1574 best = names[i].path; 1575 } 1576 /* 1577 * Still no match? Check to see if the diff could be creating 1578 * a new file. 1579 */ 1580 if (best == NULL && ok_to_create_file && 1581 names[NEW_FILE].path != NULL) 1582 best = names[NEW_FILE].path; 1583 } 1584 1585 return best ? savestr(best) : NULL; 1586 } 1587 1588 static size_t 1589 num_components(const char *path) 1590 { 1591 size_t n; 1592 const char *cp; 1593 1594 for (n = 0, cp = path; (cp = strchr(cp, '/')) != NULL; n++, cp++) { 1595 while (*cp == '/') 1596 cp++; /* skip consecutive slashes */ 1597 } 1598 return n; 1599 } 1600
Indexes created Sun Sep 21 16:09:51 GMT 2025