/* sdiff-format output routines for GNU DIFF. Copyright (C) 1991-1993, 1998, 2001-2002, 2004, 2009-2013, 2015-2025 Free Software Foundation, Inc. This file is part of GNU DIFF. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. No author or distributor accepts responsibility to anyone for the consequences of using it or for whether it serves any particular purpose or works at all, unless he says so in writing. Refer to the GNU General Public License for full details. Everyone is granted permission to copy, modify and redistribute GNU DIFF, but only under the conditions described in the GNU General Public License. A copy of this license is supposed to have been given to you along with GNU DIFF so you can know your rights and responsibilities. It should be in a file named COPYING. Among other things, the copyright notice and this notice must be preserved on all copies. */ #include "diff.h" #include static void print_sdiff_common_lines (lin, lin); static void print_sdiff_hunk (struct change *); /* Next line number to be printed in the two input files. */ static lin next0, next1; /* Print the edit-script SCRIPT as a sdiff style output. */ void print_sdiff_script (struct change *script) { begin_output (); next0 = next1 = - curr.file[0].prefix_lines; print_script (script, find_change, print_sdiff_hunk); print_sdiff_common_lines (curr.file[0].valid_lines, curr.file[1].valid_lines); } /* Tab from column FROM to column TO, where FROM <= TO. Yield TO. */ static intmax_t tab_from_to (intmax_t from, intmax_t to) { FILE *out = outfile; if (!expand_tabs) { intmax_t tab_size = tabsize; for (intmax_t tab = from + tab_size - from % tab_size; tab <= to; tab += tab_size) { putc ('\t', out); from = tab; } } while (from++ < to) putc (' ', out); return to; } /* Print the text for half an sdiff line. This means truncate to OUT_BOUND columns, observing tabs, and trim a trailing newline. Return the presumed column position on the output device after the write (not the number of chars). */ static intmax_t print_half_line (char const *const *line, intmax_t indent, intmax_t out_bound) { FILE *out = outfile; /* IN_POSITION is the current column position if we were outputting the entire line, i.e. ignoring OUT_BOUND. */ intmax_t in_position = 0; /* OUT_POSITION is the current column position. It stays <= OUT_BOUND at any moment. */ intmax_t out_position = 0; char const *text_pointer = line[0]; char const *text_limit = line[1]; while (text_pointer < text_limit) { char const *tp0 = text_pointer; char c = *text_pointer++; switch (c) { case '\t': { intmax_t spaces = tabsize - in_position % tabsize; intmax_t tabstop; if (ckd_add (&tabstop, in_position, spaces)) return out_position; if (in_position == out_position) { if (expand_tabs) { if (out_bound < tabstop) tabstop = out_bound; for (; out_position < tabstop; out_position++) putc (' ', out); } else if (tabstop < out_bound) { out_position = tabstop; putc (c, out); } } in_position = tabstop; } break; case '\r': { putc (c, out); tab_from_to (0, indent); in_position = out_position = 0; } break; case '\b': if (in_position != 0 && --in_position < out_bound) { if (out_position <= in_position) /* Add spaces to make up for suppressed tab past out_bound. */ for (; out_position < in_position; out_position++) putc (' ', out); else { out_position = in_position; putc (c, out); } } break; default: { /* A byte that might start a multibyte character. Increase TEXT_POINTER, counting columns. Assume encoding errors have print width 1. */ mcel_t g = mcel_scan (tp0, text_limit); int width = g.err ? 1 : c32width (g.ch); if (0 < width && ckd_add (&in_position, in_position, width)) return out_position; /* If there is room, output the bytes since TP0. */ if (in_position <= out_bound) { out_position = in_position; fwrite (tp0, 1, g.len, out); } text_pointer = tp0 + g.len; } break; /* Print width 1. */ case ' ': case '!': case '"': case '#': case '$': case '%': case '&': case '\'': case '(': case ')': case '*': case '+': case ',': case '-': case '.': case '/': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case ':': case ';': case '<': case '=': case '>': case '?': case '@': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '[': case '\\': case ']': case '^': case '_': case '`': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': case '{': case '|': case '}': case '~': if (ckd_add (&in_position, in_position, 1)) return out_position; if (in_position <= out_bound) { out_position = in_position; putc (c, out); } break; /* Print width 0. */ case '\0': case '\a': case '\f': case '\v': if (in_position <= out_bound) putc (c, out); break; case '\n': return out_position; } } return out_position; } /* Print side by side lines with a separator in the middle. 0 parameters are taken to indicate white space text. Blank lines that can easily be caught are reduced to a single newline. */ static void print_1sdiff_line (char const *const *left, char sep, char const *const *right) { FILE *out = outfile; intmax_t hw = sdiff_half_width; intmax_t c2o = sdiff_column2_offset; intmax_t col = 0; bool put_newline = false; bool color_to_reset = false; if (sep == '<') { set_color_context (DELETE_CONTEXT); color_to_reset = true; } else if (sep == '>') { set_color_context (ADD_CONTEXT); color_to_reset = true; } if (left) { put_newline |= left[1][-1] == '\n'; col = print_half_line (left, 0, hw); } if (sep != ' ') { col = tab_from_to (col, (hw + c2o - 1) >> 1) + 1; if (sep == '|' && put_newline != (right[1][-1] == '\n')) sep = put_newline ? '/' : '\\'; putc (sep, out); } if (right) { put_newline |= right[1][-1] == '\n'; if (**right != '\n') { col = tab_from_to (col, c2o); print_half_line (right, col, hw); } } if (put_newline) putc ('\n', out); if (color_to_reset) set_color_context (RESET_CONTEXT); } /* Print lines common to both files in side-by-side format. */ static void print_sdiff_common_lines (lin limit0, lin limit1) { lin i0 = next0, i1 = next1; if (!suppress_common_lines && (i0 != limit0 || i1 != limit1)) { if (sdiff_merge_assist) fprintf (outfile, "i%"pI"d,%"pI"d\n", limit0 - i0, limit1 - i1); if (!left_column) { while (i0 != limit0 && i1 != limit1) print_1sdiff_line (&curr.file[0].linbuf[i0++], ' ', &curr.file[1].linbuf[i1++]); while (i1 != limit1) print_1sdiff_line (0, ')', &curr.file[1].linbuf[i1++]); } while (i0 != limit0) print_1sdiff_line (&curr.file[0].linbuf[i0++], '(', 0); } next0 = limit0; next1 = limit1; } /* Print a hunk of an sdiff diff. This is a contiguous portion of a complete edit script, describing changes in consecutive lines. */ static void print_sdiff_hunk (struct change *hunk) { /* Determine range of line numbers involved in each file. */ lin first0, last0, first1, last1; enum changes changes = analyze_hunk (hunk, &first0, &last0, &first1, &last1); if (!changes) return; /* Print out lines up to this change. */ print_sdiff_common_lines (first0, first1); if (sdiff_merge_assist) fprintf (outfile, "c%"pI"d,%"pI"d\n", last0 - first0 + 1, last1 - first1 + 1); /* Print "xxx | xxx " lines. */ if (changes == CHANGED) { lin i, j; for (i = first0, j = first1; i <= last0 && j <= last1; i++, j++) print_1sdiff_line (&curr.file[0].linbuf[i], '|', &curr.file[1].linbuf[j]); changes = (i <= last0 ? OLD : 0) + (j <= last1 ? NEW : 0); next0 = first0 = i; next1 = first1 = j; } /* Print " > xxx " lines. */ if (changes & NEW) { lin j; for (j = first1; j <= last1; ++j) print_1sdiff_line (0, '>', &curr.file[1].linbuf[j]); next1 = j; } /* Print "xxx < " lines. */ if (changes & OLD) { lin i; for (i = first0; i <= last0; ++i) print_1sdiff_line (&curr.file[0].linbuf[i], '<', 0); next0 = i; } }