| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| if (eol < old_text + old_len) eol++; /* include the newline */ |
6 |
0 |
6 |
|
| 47 |
6 |
▶ | if (old_count >= old_cap) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| if (eol < new_text + new_len) eol++; |
6 |
0 |
6 |
|
| 64 |
6 |
▶ | if (new_count >= new_cap) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| && 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
| Branch | True | False | Total |
| && 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| if (i < old_count) { |
2 |
2 |
4 |
|
| 106 |
2 |
▶ | if (hunk_old_count >= hunk_cap) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| if (i < new_count) { |
2 |
2 |
4 |
|
| 114 |
2 |
▶ | if (hunk_new_count >= hunk_cap) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| if (same || i == max) { |
4 |
4 |
8 |
| if (same || i == max) { |
2 |
2 |
4 |
|
| 123 |
6 |
▶ | if (hunk_start >= 0) { |
Branch: 1 branch
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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
| Branch | True | False | Total |
| 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 */ |