include/eshu_diff.h

filter: Statementstmt 85.2% 81 / 95 Branchbran 76.5% 49 / 64 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 81.7% 130 / 159 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« include/eshu_pl.h ↑ Summary include/eshu_py.h »
1 /*
2 * eshu_diff.h — Simple unified-diff generator
3 *
4 * Pure C, no Perl dependencies.
5 */
6  
7 #ifndef ESHU_DIFF_H
8 #define ESHU_DIFF_H
9  
10 #include "eshu.h"
11 #include <stdio.h>
12  
13 /* Generate a simple unified diff between old and new text.
14 * Returns a malloc'd string (caller must free). */
15 2 static char *eshu_simple_diff(const char *label,
16 const char *old_text, size_t old_len,
17 const char *new_text, size_t new_len,
18 size_t *out_len)
19 {
20 eshu_buf_t buf;
21 /* Split both into line arrays */
22 2 size_t old_cap = 256, new_cap = 256;
23 2 size_t old_count = 0, new_count = 0;
24 const char **old_lines, **new_lines;
25 size_t *old_lens, *new_lens;
26 const char *p;
27 size_t i, max, hunk_old_count, hunk_new_count;
28 int hunk_start;
29 /* Temp arrays for hunk lines */
30 2 size_t hunk_cap = 64;
31 size_t *ho_idx, *hn_idx;
32 char numbuf[64];
33  
34 2 eshu_buf_init(&buf, old_len > new_len ? old_len : new_len);
35  
36 2 old_lines = (const char **)malloc(old_cap * sizeof(const char *));
37 2 old_lens = (size_t *)malloc(old_cap * sizeof(size_t));
38 2 new_lines = (const char **)malloc(new_cap * sizeof(const char *));
39 2 new_lens = (size_t *)malloc(new_cap * sizeof(size_t));
40  
41 /* Parse old lines */
42 2 p = old_text;
43 8 ▶ while (p < old_text + old_len) {
Branch: 1 branch
BranchTrueFalseTotal
while (p < old_text + old_len) { 6 2 8
44 6 const char *eol = p;
45 37 ▶ while (eol < old_text + old_len && *eol != '\n') eol++;
Branch: 2 branches
BranchTrueFalseTotal
while (eol < old_text + old_len && *eol != '\n') eol++; 37 0 37
while (eol < old_text + old_len && *eol != '\n') eol++; 31 6 37
46 6 ▶ if (eol < old_text + old_len) eol++; /* include the newline */
Branch: 1 branch
BranchTrueFalseTotal
if (eol < old_text + old_len) eol++; /* include the newline */ 6 0 6
47 6 ▶ if (old_count >= old_cap) {
Branch: 1 branch
BranchTrueFalseTotal
if (old_count >= old_cap) { 0 6 6
48 0 old_cap *= 2;
49 0 old_lines = (const char **)realloc(old_lines, old_cap * sizeof(const char *));
50 0 old_lens = (size_t *)realloc(old_lens, old_cap * sizeof(size_t));
51 }
52 6 old_lines[old_count] = p;
53 6 old_lens[old_count] = (size_t)(eol - p);
54 6 old_count++;
55 6 p = eol;
56 }
57  
58 /* Parse new lines */
59 2 p = new_text;
60 8 ▶ while (p < new_text + new_len) {
Branch: 1 branch
BranchTrueFalseTotal
while (p < new_text + new_len) { 6 2 8
61 6 const char *eol = p;
62 39 ▶ while (eol < new_text + new_len && *eol != '\n') eol++;
Branch: 2 branches
BranchTrueFalseTotal
while (eol < new_text + new_len && *eol != '\n') eol++; 39 0 39
while (eol < new_text + new_len && *eol != '\n') eol++; 33 6 39
63 6 ▶ if (eol < new_text + new_len) eol++;
Branch: 1 branch
BranchTrueFalseTotal
if (eol < new_text + new_len) eol++; 6 0 6
64 6 ▶ if (new_count >= new_cap) {
Branch: 1 branch
BranchTrueFalseTotal
if (new_count >= new_cap) { 0 6 6
65 0 new_cap *= 2;
66 0 new_lines = (const char **)realloc(new_lines, new_cap * sizeof(const char *));
67 0 new_lens = (size_t *)realloc(new_lens, new_cap * sizeof(size_t));
68 }
69 6 new_lines[new_count] = p;
70 6 new_lens[new_count] = (size_t)(eol - p);
71 6 new_count++;
72 6 p = eol;
73 }
74  
75 /* Header */
76 2 eshu_buf_write(&buf, "--- a/", 6);
77 2 eshu_buf_write(&buf, label, strlen(label));
78 2 eshu_buf_putc(&buf, '\n');
79 2 eshu_buf_write(&buf, "+++ b/", 6);
80 2 eshu_buf_write(&buf, label, strlen(label));
81 2 eshu_buf_putc(&buf, '\n');
82  
83 2 ho_idx = (size_t *)malloc(hunk_cap * sizeof(size_t));
84 2 hn_idx = (size_t *)malloc(hunk_cap * sizeof(size_t));
85  
86 2 max = old_count > new_count ? old_count : new_count;
87 2 hunk_start = -1;
88 2 hunk_old_count = 0;
89 2 hunk_new_count = 0;
90  
91 10 ▶ for (i = 0; i <= max; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i <= max; i++) { 8 2 10
92 8 int same = 0;
93 8 ▶ if (i < old_count && i < new_count
Branch: 2 branches
BranchTrueFalseTotal
if (i < old_count && i < new_count 6 2 8
if (i < old_count && i < new_count 6 0 6
94 6 ▶ && old_lens[i] == new_lens[i]
Branch: 1 branch
BranchTrueFalseTotal
&& old_lens[i] == new_lens[i] 4 2 6
95 4 ▶ && memcmp(old_lines[i], new_lines[i], old_lens[i]) == 0) {
Branch: 1 branch
BranchTrueFalseTotal
&& memcmp(old_lines[i], new_lines[i], old_lens[i]) == 0) { 4 0 4
96 4 same = 1;
97 }
98  
99 8 ▶ if (!same && hunk_start < 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (!same && hunk_start < 0) { 4 4 8
if (!same && hunk_start < 0) { 4 0 4
100 4 hunk_start = (int)i;
101 4 hunk_old_count = 0;
102 4 hunk_new_count = 0;
103 }
104 8 ▶ if (hunk_start >= 0 && !same) {
Branch: 2 branches
BranchTrueFalseTotal
if (hunk_start >= 0 && !same) { 6 2 8
if (hunk_start >= 0 && !same) { 4 2 6
105 4 ▶ if (i < old_count) {
Branch: 1 branch
BranchTrueFalseTotal
if (i < old_count) { 2 2 4
106 2 ▶ if (hunk_old_count >= hunk_cap) {
Branch: 1 branch
BranchTrueFalseTotal
if (hunk_old_count >= hunk_cap) { 0 2 2
107 0 hunk_cap *= 2;
108 0 ho_idx = (size_t *)realloc(ho_idx, hunk_cap * sizeof(size_t));
109 0 hn_idx = (size_t *)realloc(hn_idx, hunk_cap * sizeof(size_t));
110 }
111 2 ho_idx[hunk_old_count++] = i;
112 }
113 4 ▶ if (i < new_count) {
Branch: 1 branch
BranchTrueFalseTotal
if (i < new_count) { 2 2 4
114 2 ▶ if (hunk_new_count >= hunk_cap) {
Branch: 1 branch
BranchTrueFalseTotal
if (hunk_new_count >= hunk_cap) { 0 2 2
115 0 hunk_cap *= 2;
116 0 ho_idx = (size_t *)realloc(ho_idx, hunk_cap * sizeof(size_t));
117 0 hn_idx = (size_t *)realloc(hn_idx, hunk_cap * sizeof(size_t));
118 }
119 2 hn_idx[hunk_new_count++] = i;
120 }
121 }
122 8 ▶ if (same || i == max) {
Branch: 2 branches
BranchTrueFalseTotal
if (same || i == max) { 4 4 8
if (same || i == max) { 2 2 4
123 6 ▶ if (hunk_start >= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (hunk_start >= 0) { 4 2 6
124 size_t j;
125 4 int len = sprintf(numbuf, "@@ -%d,%d +%d,%d @@\n",
126 hunk_start + 1, (int)hunk_old_count,
127 hunk_start + 1, (int)hunk_new_count);
128 4 eshu_buf_write(&buf, numbuf, (size_t)len);
129 6 ▶ for (j = 0; j < hunk_old_count; j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < hunk_old_count; j++) { 2 4 6
130 2 size_t idx = ho_idx[j];
131 2 eshu_buf_putc(&buf, '-');
132 2 eshu_buf_write(&buf, old_lines[idx], old_lens[idx]);
133 2 ▶ if (old_lens[idx] == 0 || old_lines[idx][old_lens[idx]-1] != '\n')
Branch: 2 branches
BranchTrueFalseTotal
if (old_lens[idx] == 0 || old_lines[idx][old_lens[idx]-1] != '\n') 2 0 2
if (old_lens[idx] == 0 || old_lines[idx][old_lens[idx]-1] != '\n') 0 2 2
134 0 eshu_buf_putc(&buf, '\n');
135 }
136 6 ▶ for (j = 0; j < hunk_new_count; j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < hunk_new_count; j++) { 2 4 6
137 2 size_t idx = hn_idx[j];
138 2 eshu_buf_putc(&buf, '+');
139 2 eshu_buf_write(&buf, new_lines[idx], new_lens[idx]);
140 2 ▶ if (new_lens[idx] == 0 || new_lines[idx][new_lens[idx]-1] != '\n')
Branch: 2 branches
BranchTrueFalseTotal
if (new_lens[idx] == 0 || new_lines[idx][new_lens[idx]-1] != '\n') 2 0 2
if (new_lens[idx] == 0 || new_lines[idx][new_lens[idx]-1] != '\n') 0 2 2
141 0 eshu_buf_putc(&buf, '\n');
142 }
143 4 hunk_start = -1;
144 }
145 }
146 }
147  
148 2 free(ho_idx);
149 2 free(hn_idx);
150 2 free(old_lines);
151 2 free(old_lens);
152 2 free(new_lines);
153 2 free(new_lens);
154  
155 2 *out_len = buf.len;
156 2 return buf.data;
157 }
158  
159 #endif /* ESHU_DIFF_H */
« include/eshu_pl.h ↑ Summary include/eshu_py.h »