Blob


1 /* Produce ed(1) script output from a diff_result. */
2 /*
3 * Copyright (c) 2020 Neels Hofmeyr <neels@hofmeyr.de>
4 * Copyright (c) 2020 Stefan Sperling <stsp@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
19 #include <errno.h>
20 #include <stdint.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <stdbool.h>
25 #include <arraylist.h>
26 #include <diff_main.h>
27 #include <diff_output.h>
29 #include "diff_internal.h"
31 static int
32 output_edscript_chunk(struct diff_output_info *outinfo,
33 FILE *dest, const struct diff_input_info *info,
34 const struct diff_result *result,
35 struct diff_chunk_context *cc)
36 {
37 off_t outoff = 0, *offp;
38 int left_start, left_len, right_start, right_len;
39 int rc;
41 left_len = cc->left.end - cc->left.start;
42 if (left_len < 0)
43 return EINVAL;
44 else if (result->left->atoms.len == 0)
45 left_start = 0;
46 else if (left_len == 0 && cc->left.start > 0)
47 left_start = cc->left.start;
48 else if (cc->left.end > 0)
49 left_start = cc->left.start + 1;
50 else
51 left_start = cc->left.start;
53 right_len = cc->right.end - cc->right.start;
54 if (right_len < 0)
55 return EINVAL;
56 else if (result->right->atoms.len == 0)
57 right_start = 0;
58 else if (right_len == 0 && cc->right.start > 0)
59 right_start = cc->right.start;
60 else if (cc->right.end > 0)
61 right_start = cc->right.start + 1;
62 else
63 right_start = cc->right.start;
65 if (left_len == 0) {
66 /* addition */
67 if (right_len == 1) {
68 rc = fprintf(dest, "%da%d\n", left_start, right_start);
69 } else {
70 rc = fprintf(dest, "%da%d,%d\n", left_start,
71 right_start, cc->right.end);
72 }
73 } else if (right_len == 0) {
74 /* deletion */
75 if (left_len == 1) {
76 rc = fprintf(dest, "%dd%d\n", left_start,
77 right_start);
78 } else {
79 rc = fprintf(dest, "%d,%dd%d\n", left_start,
80 cc->left.end, right_start);
81 }
82 } else {
83 /* change */
84 if (left_len == 1 && right_len == 1) {
85 rc = fprintf(dest, "%dc%d\n", left_start, right_start);
86 } else if (left_len == 1) {
87 rc = fprintf(dest, "%dc%d,%d\n", left_start,
88 right_start, cc->right.end);
89 } else if (right_len == 1) {
90 rc = fprintf(dest, "%d,%dc%d\n", left_start,
91 cc->left.end, right_start);
92 } else {
93 rc = fprintf(dest, "%d,%dc%d,%d\n", left_start,
94 cc->left.end, right_start, cc->right.end);
95 }
96 }
97 if (rc < 0)
98 return errno;
99 if (outinfo) {
100 ARRAYLIST_ADD(offp, outinfo->line_offsets);
101 if (offp == NULL)
102 return ENOMEM;
103 outoff += rc;
104 *offp = outoff;
107 return DIFF_RC_OK;
110 int
111 diff_output_edscript(struct diff_output_info **output_info,
112 FILE *dest, const struct diff_input_info *info,
113 const struct diff_result *result)
115 struct diff_output_info *outinfo = NULL;
116 struct diff_chunk_context cc = {};
117 int atomizer_flags = (result->left->atomizer_flags|
118 result->right->atomizer_flags);
119 int flags = (result->left->root->diff_flags |
120 result->right->root->diff_flags);
121 bool force_text = (flags & DIFF_FLAG_FORCE_TEXT_DATA);
122 bool have_binary = (atomizer_flags & DIFF_ATOMIZER_FOUND_BINARY_DATA);
123 int i, rc;
125 if (!result)
126 return EINVAL;
127 if (result->rc != DIFF_RC_OK)
128 return result->rc;
130 if (output_info) {
131 *output_info = diff_output_info_alloc();
132 if (*output_info == NULL)
133 return ENOMEM;
134 outinfo = *output_info;
137 if (have_binary && !force_text) {
138 for (i = 0; i < result->chunks.len; i++) {
139 struct diff_chunk *c = &result->chunks.head[i];
140 enum diff_chunk_type t = diff_chunk_type(c);
142 if (t != CHUNK_MINUS && t != CHUNK_PLUS)
143 continue;
145 fprintf(dest, "Binary files %s and %s differ\n",
146 diff_output_get_label_left(info),
147 diff_output_get_label_right(info));
148 break;
151 return DIFF_RC_OK;
154 for (i = 0; i < result->chunks.len; i++) {
155 struct diff_chunk *chunk = &result->chunks.head[i];
156 enum diff_chunk_type t = diff_chunk_type(chunk);
157 struct diff_chunk_context next;
159 if (t != CHUNK_MINUS && t != CHUNK_PLUS)
160 continue;
162 if (diff_chunk_context_empty(&cc)) {
163 /* Note down the start point, any number of subsequent
164 * chunks may be joined up to this chunk by being
165 * directly adjacent. */
166 diff_chunk_context_get(&cc, result, i, 0);
167 continue;
170 /* There already is a previous chunk noted down for being
171 * printed. Does it join up with this one? */
172 diff_chunk_context_get(&next, result, i, 0);
174 if (diff_chunk_contexts_touch(&cc, &next)) {
175 /* This next context touches or overlaps the previous
176 * one, join. */
177 diff_chunk_contexts_merge(&cc, &next);
178 continue;
181 rc = output_edscript_chunk(outinfo, dest, info, result, &cc);
182 if (rc != DIFF_RC_OK)
183 return rc;
184 cc = next;
187 if (!diff_chunk_context_empty(&cc))
188 return output_edscript_chunk(outinfo, dest, info, result, &cc);
189 return DIFF_RC_OK;