1 /* Output all lines of a diff_result. */
2 /*
3  * Copyright (c) 2020 Neels Hofmeyr <neels@hofmeyr.de>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include <errno.h>
19 #include <stdint.h>
20 #include <stdio.h>
21 #include <stdbool.h>
22 #include <stdlib.h>
23 
24 #include <arraylist.h>
25 #include <diff_main.h>
26 #include <diff_output.h>
27 
28 #include "diff_internal.h"
29 
30 static int
31 output_plain_chunk(struct diff_output_info *outinfo,
32     FILE *dest, const struct diff_input_info *info,
33     const struct diff_result *result,
34     struct diff_chunk_context *cc, off_t *outoff)
35 {
36 	off_t *offp;
37 	int left_start, left_len, right_start, right_len;
38 	int rc;
39 	bool change = false;
40 
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;
52 
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;
64 
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 		change = true;
85 		if (left_len == 1 && right_len == 1) {
86 			rc = fprintf(dest, "%dc%d\n", left_start, right_start);
87 		} else if (left_len == 1) {
88 			rc = fprintf(dest, "%dc%d,%d\n", left_start,
89 			    right_start, cc->right.end);
90 		} else if (right_len == 1) {
91 			rc = fprintf(dest, "%d,%dc%d\n", left_start,
92 			    cc->left.end, right_start);
93 		} else {
94 			rc = fprintf(dest, "%d,%dc%d,%d\n", left_start,
95 			    cc->left.end, right_start, cc->right.end);
96 		}
97 	}
98 	if (rc < 0)
99 		return errno;
100 	if (outinfo) {
101 		ARRAYLIST_ADD(offp, outinfo->line_offsets);
102 		if (offp == NULL)
103 			return ENOMEM;
104 		*outoff += rc;
105 		*offp = *outoff;
106 	}
107 
108 	/*
109 	 * Now write out all the joined chunks.
110 	 *
111 	 * If the hunk denotes a change, it will come in the form of a deletion
112 	 * chunk followed by a addition chunk. Print a marker to break up the
113 	 * additions and deletions when this happens.
114 	 */
115 	int c_idx;
116 	for (c_idx = cc->chunk.start; c_idx < cc->chunk.end; c_idx++) {
117 		const struct diff_chunk *c = &result->chunks.head[c_idx];
118 		if (c->left_count && !c->right_count)
119 			rc = diff_output_lines(outinfo, dest,
120 					  c->solved ? "< " : "?",
121 					  c->left_start, c->left_count);
122 		else if (c->right_count && !c->left_count) {
123 			if (change) {
124 				rc = fprintf(dest, "---\n");
125 				if (rc < 0)
126 					return errno;
127 				if (outinfo) {
128 					ARRAYLIST_ADD(offp,
129 					    outinfo->line_offsets);
130 					if (offp == NULL)
131 						return ENOMEM;
132 					*outoff += rc;
133 					*offp = *outoff;
134 				}
135 			}
136 			rc = diff_output_lines(outinfo, dest,
137 					  c->solved ? "> " : "?",
138 					  c->right_start, c->right_count);
139 		}
140 		if (rc)
141 			return rc;
142 		if (cc->chunk.end == result->chunks.len) {
143 			rc = diff_output_trailing_newline_msg(outinfo, dest, c);
144 			if (rc != DIFF_RC_OK)
145 				return rc;
146 		}
147 	}
148 
149 	return DIFF_RC_OK;
150 }
151 
152 int
153 diff_output_plain(struct diff_output_info **output_info,
154     FILE *dest, const struct diff_input_info *info,
155     const struct diff_result *result)
156 {
157 	struct diff_output_info *outinfo = NULL;
158 	struct diff_chunk_context cc = {};
159 	int atomizer_flags = (result->left->atomizer_flags|
160 	    result->right->atomizer_flags);
161 	int flags = (result->left->root->diff_flags |
162 	    result->right->root->diff_flags);
163 	bool force_text = (flags & DIFF_FLAG_FORCE_TEXT_DATA);
164 	bool have_binary = (atomizer_flags & DIFF_ATOMIZER_FOUND_BINARY_DATA);
165 	int i, rc;
166 	off_t outoff = 0, *offp;
167 
168 	if (!result)
169 		return EINVAL;
170 	if (result->rc != DIFF_RC_OK)
171 		return result->rc;
172 
173 	if (output_info) {
174 		*output_info = diff_output_info_alloc();
175 		if (*output_info == NULL)
176 			return ENOMEM;
177 		outinfo = *output_info;
178 	}
179 
180 	if (have_binary && !force_text) {
181 		for (i = 0; i < result->chunks.len; i++) {
182 			struct diff_chunk *c = &result->chunks.head[i];
183 			enum diff_chunk_type t = diff_chunk_type(c);
184 
185 			if (t != CHUNK_MINUS && t != CHUNK_PLUS)
186 				continue;
187 
188 			rc = fprintf(dest, "Binary files %s and %s differ\n",
189 			    diff_output_get_label_left(info),
190 			    diff_output_get_label_right(info));
191 			if (rc < 0)
192 				return errno;
193 			if (outinfo) {
194 				ARRAYLIST_ADD(offp, outinfo->line_offsets);
195 				if (offp == NULL)
196 					return ENOMEM;
197 				outoff += rc;
198 				*offp = outoff;
199 			}
200 			break;
201 		}
202 
203 		return DIFF_RC_OK;
204 	}
205 
206 	for (i = 0; i < result->chunks.len; i++) {
207 		struct diff_chunk *chunk = &result->chunks.head[i];
208 		enum diff_chunk_type t = diff_chunk_type(chunk);
209 		struct diff_chunk_context next;
210 
211 		if (t != CHUNK_MINUS && t != CHUNK_PLUS)
212 			continue;
213 
214 		if (diff_chunk_context_empty(&cc)) {
215 			/* Note down the start point, any number of subsequent
216 			 * chunks may be joined up to this chunk by being
217 			 * directly adjacent. */
218 			diff_chunk_context_get(&cc, result, i, 0);
219 			continue;
220 		}
221 
222 		/* There already is a previous chunk noted down for being
223 		 * printed. Does it join up with this one? */
224 		diff_chunk_context_get(&next, result, i, 0);
225 
226 		if (diff_chunk_contexts_touch(&cc, &next)) {
227 			/* This next context touches or overlaps the previous
228 			 * one, join. */
229 			diff_chunk_contexts_merge(&cc, &next);
230 			/* When we merge the last chunk we can end up with one
231 			 * hanging chunk and have to come back for it after the
232 			 * loop */
233 			continue;
234 		}
235 		rc = output_plain_chunk(outinfo, dest, info, result, &cc,
236 		    &outoff);
237 		if (rc != DIFF_RC_OK)
238 			return rc;
239 		cc = next;
240 	}
241 	if (!diff_chunk_context_empty(&cc))
242 		return output_plain_chunk(outinfo, dest, info, result, &cc,
243 		    &outoff);
244 	return DIFF_RC_OK;
245 }