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  */
18 
19 #include <errno.h>
20 #include <stdint.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <stdbool.h>
24 
25 #include <arraylist.h>
26 #include <diff_main.h>
27 #include <diff_output.h>
28 
29 #include "diff_internal.h"
30 
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;
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
49 		left_start = cc->left.start + 1;
50 
51 	right_len = cc->right.end - cc->right.start;
52 	if (right_len < 0)
53 		return EINVAL;
54 	else if (result->right->atoms.len == 0)
55 		right_start = 0;
56 	else if (right_len == 0 && cc->right.start > 0)
57 		right_start = cc->right.start;
58 	else
59 		right_start = cc->right.start + 1;
60 
61 	if (left_len == 0) {
62 		/* addition */
63 		if (right_len == 1) {
64 			rc = fprintf(dest, "%da%d\n", left_start, right_start);
65 		} else {
66 			rc = fprintf(dest, "%da%d,%d\n", left_start,
67 			    right_start, cc->right.end);
68 		}
69 	} else if (right_len == 0) {
70 		/* deletion */
71 		if (left_len == 1) {
72 			rc = fprintf(dest, "%dd%d\n", left_start,
73 			    right_start);
74 		} else {
75 			rc = fprintf(dest, "%d,%dd%d\n", left_start,
76 			    cc->left.end, right_start);
77 		}
78 	} else {
79 		/* change */
80 		if (left_len == 1 && right_len == 1) {
81 			rc = fprintf(dest, "%dc%d\n", left_start, right_start);
82 		} else if (left_len == 1) {
83 			rc = fprintf(dest, "%dc%d,%d\n", left_start,
84 			    right_start, cc->right.end);
85 		} else if (right_len == 1) {
86 			rc = fprintf(dest, "%d,%dc%d\n", left_start,
87 			    cc->left.end, right_start);
88 		} else {
89 			rc = fprintf(dest, "%d,%dc%d,%d\n", left_start,
90 			    cc->left.end, right_start, cc->right.end);
91 		}
92 	}
93 	if (rc < 0)
94 		return errno;
95 	if (outinfo) {
96 		ARRAYLIST_ADD(offp, outinfo->line_offsets);
97 		if (offp == NULL)
98 			return ENOMEM;
99 		outoff += rc;
100 		*offp = outoff;
101 	}
102 
103 	return DIFF_RC_OK;
104 }
105 
106 int
107 diff_output_edscript(struct diff_output_info **output_info,
108     FILE *dest, const struct diff_input_info *info,
109     const struct diff_result *result)
110 {
111 	struct diff_output_info *outinfo = NULL;
112 	struct diff_chunk_context cc = {};
113 	int atomizer_flags = (result->left->atomizer_flags|
114 	    result->right->atomizer_flags);
115 	int flags = (result->left->root->diff_flags |
116 	    result->right->root->diff_flags);
117 	bool force_text = (flags & DIFF_FLAG_FORCE_TEXT_DATA);
118 	bool have_binary = (atomizer_flags & DIFF_ATOMIZER_FOUND_BINARY_DATA);
119 	int i, rc;
120 
121 	if (!result)
122 		return EINVAL;
123 	if (result->rc != DIFF_RC_OK)
124 		return result->rc;
125 
126 	if (output_info) {
127 		*output_info = diff_output_info_alloc();
128 		if (*output_info == NULL)
129 			return ENOMEM;
130 		outinfo = *output_info;
131 	}
132 
133 	if (have_binary && !force_text) {
134 		for (i = 0; i < result->chunks.len; i++) {
135 			struct diff_chunk *c = &result->chunks.head[i];
136 			enum diff_chunk_type t = diff_chunk_type(c);
137 
138 			if (t != CHUNK_MINUS && t != CHUNK_PLUS)
139 				continue;
140 
141 			fprintf(dest, "Binary files %s and %s differ\n",
142 			    diff_output_get_label_left(info),
143 			    diff_output_get_label_right(info));
144 			break;
145 		}
146 
147 		return DIFF_RC_OK;
148 	}
149 
150 	for (i = 0; i < result->chunks.len; i++) {
151 		struct diff_chunk *chunk = &result->chunks.head[i];
152 		enum diff_chunk_type t = diff_chunk_type(chunk);
153 		struct diff_chunk_context next;
154 
155 		if (t != CHUNK_MINUS && t != CHUNK_PLUS)
156 			continue;
157 
158 		if (diff_chunk_context_empty(&cc)) {
159 			/* Note down the start point, any number of subsequent
160 			 * chunks may be joined up to this chunk by being
161 			 * directly adjacent. */
162 			diff_chunk_context_get(&cc, result, i, 0);
163 			continue;
164 		}
165 
166 		/* There already is a previous chunk noted down for being
167 		 * printed. Does it join up with this one? */
168 		diff_chunk_context_get(&next, result, i, 0);
169 
170 		if (diff_chunk_contexts_touch(&cc, &next)) {
171 			/* This next context touches or overlaps the previous
172 			 * one, join. */
173 			diff_chunk_contexts_merge(&cc, &next);
174 			continue;
175 		}
176 
177 		rc = output_edscript_chunk(outinfo, dest, info, result, &cc);
178 		if (rc != DIFF_RC_OK)
179 			return rc;
180 		cc = next;
181 	}
182 
183 	if (!diff_chunk_context_empty(&cc))
184 		return output_edscript_chunk(outinfo, dest, info, result, &cc);
185 	return DIFF_RC_OK;
186 }