| /* diff.c - compare files line by line |
| * |
| * Copyright 2014 Sandeep Sharma <sandeep.jack2756@gmail.com> |
| * Copyright 2014 Ashwini Kumar <ak.ashwini1981@gmail.com> |
| * |
| * See https://pubs.opengroup.org/onlinepubs/9699919799/utilities/diff.html |
| * and https://www.cs.dartmouth.edu/~doug/diff.pdf |
| * |
| * Deviations from posix: always does -u |
| |
| USE_DIFF(NEWTOY(diff, "<2>2(unchanged-line-format):;(old-line-format):;(new-line-format):;(color)(strip-trailing-cr)B(ignore-blank-lines)d(minimal)b(ignore-space-change)ut(expand-tabs)w(ignore-all-space)i(ignore-case)T(initial-tab)s(report-identical-files)q(brief)a(text)S(starting-file):F(show-function-line):;L(label)*N(new-file)r(recursive)U(unified)#<0=3", TOYFLAG_USR|TOYFLAG_BIN|TOYFLAG_ARGFAIL(2))) |
| |
| config DIFF |
| bool "diff" |
| default n |
| help |
| usage: diff [-abBdiNqrTstw] [-L LABEL] [-S FILE] [-U LINES] [-F REGEX ] FILE1 FILE2 |
| |
| -a Treat all files as text |
| -b Ignore changes in the amount of whitespace |
| -B Ignore changes whose lines are all blank |
| -d Try hard to find a smaller set of changes |
| -F Show the most recent line matching the regex |
| -i Ignore case differences |
| -L Use LABEL instead of the filename in the unified header |
| -N Treat absent files as empty |
| -q Output only whether files differ |
| -r Recurse |
| -S Start with FILE when comparing directories |
| -s Report when two files are the same |
| -T Make tabs line up by prefixing a tab when necessary |
| -t Expand tabs to spaces in output |
| -u Unified diff |
| -U Output LINES lines of context |
| -w Ignore all whitespace |
| |
| --color Color output --strip-trailing-cr Strip '\r' from input lines |
| --TYPE-line-format=FORMAT Display TYPE (unchanged/old/new) lines using FORMAT |
| FORMAT uses printf integer escapes (ala %-2.4x) followed by LETTER: FELMNn |
| Supported format specifiers are: |
| * %l, the contents of the line, without the trailing newline |
| * %L, the contents of the line, including the trailing newline |
| * %%, the character '%' |
| */ |
| |
| #define FOR_diff |
| #include "toys.h" |
| |
| GLOBALS( |
| long U; |
| struct arg_list *L; |
| char *F, *S, *new_line_format, *old_line_format, *unchanged_line_format; |
| |
| int dir_num, size, is_binary, differ, change, len[2], *offset[2]; |
| struct stat st[2]; |
| struct { |
| char **list; |
| int nr_elm; |
| } dir[2]; |
| struct { |
| FILE *fp; |
| int len; |
| } file[2]; |
| ) |
| |
| #define IS_STDIN(s) (*(s)=='-' && !(s)[1]) |
| |
| struct v_vector { |
| unsigned serial:31; |
| unsigned last:1; |
| union { |
| unsigned hash; |
| unsigned p; |
| }; |
| }; |
| |
| struct diff { |
| long a, b, c, d, prev, suff; |
| }; |
| |
| struct candidate { |
| struct candidate *next, *prev; |
| int a, b; |
| }; |
| |
| enum { |
| empty = 1 << 9, |
| eol = 1 << 10, |
| eof = 1 << 11, |
| space = 1 << 12 |
| }; |
| |
| static int comp(void *a, void *b) |
| { |
| int i = ((struct v_vector *)a)->hash - ((struct v_vector *)b)->hash; |
| |
| return i ? : ((struct v_vector *)a)->serial - ((struct v_vector *)b)->serial; |
| } |
| |
| static int search(struct candidate **K, int r, int k, int j) |
| { |
| int low = r, upper = k, mid; |
| |
| while (low<=(mid = (low+upper)/2)) { |
| if (K[mid]->b < j && K[mid + 1]->b > j) return mid; |
| if (K[mid]->b < j) low = mid + 1; |
| else if (K[mid]->b > j) upper = mid - 1; |
| else return -1; |
| } |
| return -1; |
| } |
| |
| static struct candidate *new_candidate(int i, int j, struct candidate *prev) |
| { |
| struct candidate *c = xzalloc(sizeof(struct candidate)); |
| |
| c->a = i; |
| c->b = j; |
| c->prev = prev; |
| return c; |
| } |
| |
| /* 1. Search K[r: k] for an element K[s] such that K[s]-> b < j and K[s + 1]->b > j |
| * 2. if found do |
| * 2.a. If K[s + 1]->b > j do K[r] = c; r = s+1 and c = candidate(i, j, K[s]) //we have a candidate |
| * 2.b. if s = k (fence reached move it further) do K[k + 2] = K[k + 1], k++ |
| * 3. if E[p].last true break i.e we have reached at the end of an equiv class |
| * else p = p + 1 //keep traversing the equiv class. |
| * 4. K[r] = c //Save the sucessfully filled k-candidate. |
| */ |
| static void do_merge(struct candidate **K, int *k, int i, |
| struct v_vector *E, int p) |
| { |
| int r = 0, s, j; |
| struct candidate *pr = 0, *c = K[0]; |
| |
| for (;;) { |
| j = E[p].serial; |
| s = search(K, r, *k, j); |
| if (s>=0 && K[s]->b<j && K[s+1]->b>j) { |
| if (K[s+1]->b>j) { |
| pr = K[s]; |
| if (r && K[r]) c->next = K[r]; |
| K[r] = c; |
| r = s+1; |
| c = new_candidate(i , j, pr); |
| } |
| if (s == *k) { |
| ++*k; |
| K[*k+1] = K[*k]; |
| break; |
| } |
| } |
| if (E[p].last) break; |
| else p++; |
| } |
| K[r] = c; |
| } |
| |
| static int read_tok(FILE *fp, off_t *off, int tok) |
| { |
| int t = 0, is_space; |
| |
| tok |= empty; |
| while (!(tok & eol)) { |
| t = fgetc(fp); |
| |
| if (FLAG(strip_trailing_cr) && t == '\r') { |
| int t2 = fgetc(fp); |
| if (t2 == '\n') { |
| t = t2; |
| if (off) (*off)++; |
| } else { |
| ungetc(t2, fp); |
| } |
| } |
| |
| if (off && t != EOF) *off += 1; |
| is_space = isspace(t) || (t == EOF); |
| tok |= (t & (eof + eol)); //set tok eof+eol when t is eof |
| |
| if (t == '\n') tok |= eol; |
| if (FLAG(i)) if (t >= 'A' && t <= 'Z') t = tolower(t); |
| |
| if (FLAG(w) && is_space) continue; |
| |
| if (FLAG(b)) { |
| if (tok & space) { |
| if (is_space) continue; |
| tok &= ~space; |
| } else if (is_space) t = space + ' '; |
| } |
| tok &= ~(empty + 0xff); //remove empty and char too. |
| tok |= t; //add most recent char |
| break; |
| } |
| |
| return tok; |
| } |
| |
| int bcomp(void *a, void *b) |
| { |
| struct v_vector *l = (struct v_vector *)a, *r = (struct v_vector *)b; |
| |
| return (l->hash-r->hash) ? : r[-1].last ? 0 : -1; |
| } |
| |
| /* file[0] corresponds file 1 and file[1] correspond file 2. |
| * 1. calc hashes for both the files and store them in vector(v[0], v[1]) |
| * 2. sort file[1] with hash as primary and serial as sec. key |
| * 3. Form the equivalance class of file[1] stored in e vector. It lists all the equivalence |
| * classes of lines in file[1], with e.last = true on the last element of each class. |
| * The elements are ordered by serial within classes. |
| * 4. Form the p vector stored in p_vector. p_vector[i], if non-zero, now points in e vector |
| * to the beginning of the equiv class of lines in file[1] equivalent to line |
| * i in file[0]. |
| * 5. Form the k-candidates as discribed in do_merge. |
| * 6. Create a vector J[i] = j, such that i'th line in file[0] is j'th line of |
| * file[1], i.e J comprises LCS |
| */ |
| static int *create_j_vector() |
| { |
| int tok, i, j, size = 100, k; |
| off_t off; |
| long hash; |
| int *p_vector, *J; |
| struct v_vector *v[2], *e; |
| struct candidate **kcand, *pr; |
| |
| for (i = 0; i < 2; i++) { |
| tok = off = 0; |
| hash = 5831; |
| v[i] = xzalloc(size * sizeof(struct v_vector)); |
| TT.offset[i] = xzalloc(size * sizeof(int)); |
| TT.file[i].len = 0; |
| if (fseek(TT.file[i].fp, 0, SEEK_SET)) perror_exit("fseek failed"); |
| |
| while (1) { |
| tok = read_tok(TT.file[i].fp, &off, tok); |
| if (!(tok & empty)) { |
| hash = ((hash << 5) + hash) + (tok & 0xff); |
| continue; |
| } |
| |
| if (size == ++TT.file[i].len) { |
| size = size * 11 / 10; |
| v[i] = xrealloc(v[i], size*sizeof(struct v_vector)); |
| TT.offset[i] = xrealloc(TT.offset[i], size*sizeof(int)); |
| } |
| |
| v[i][TT.file[i].len].hash = hash & INT_MAX; |
| TT.offset[i][TT.file[i].len] = off; |
| if ((tok & eof)) { |
| TT.offset[i][TT.file[i].len] = ++off; |
| break; |
| } |
| hash = 5831; //next line |
| tok = 0; |
| } |
| if (TT.offset[i][TT.file[i].len]-TT.offset[i][TT.file[i].len-1] == 1) |
| TT.file[i].len--; |
| } |
| |
| for (i = 0; i<=TT.file[1].len; i++) v[1][i].serial = i; |
| qsort(v[1]+1, TT.file[1].len, sizeof(struct v_vector), (void *)comp); |
| |
| e = v[1]; |
| e[0].serial = 0; |
| e[0].last = 1; |
| for (i = 1; i<=TT.file[1].len; i++) |
| e[i].last = i==TT.file[1].len || v[1][i].hash!=v[1][i+1].hash; |
| |
| p_vector = xzalloc((TT.file[0].len+2)*sizeof(int)); |
| for (i = 1; i<=TT.file[0].len; i++) { |
| void *r = bsearch(&v[0][i], e+1, TT.file[1].len, sizeof(*e), (void *)bcomp); |
| if (r) p_vector[i] = (struct v_vector *)r - e; |
| } |
| |
| for (i = 1; i<=TT.file[0].len; i++) e[i].p = p_vector[i]; |
| free(p_vector); |
| |
| size = 100; |
| kcand = xzalloc(size * sizeof(struct candidate *)); |
| |
| kcand[0] = new_candidate(0 , 0, 0); |
| kcand[1] = new_candidate(TT.file[0].len+1, TT.file[1].len+1, 0); //the fence |
| |
| k = 0; //last successfully filled k candidate. |
| for (i = 1; i<=TT.file[0].len; i++) { |
| if (!e[i].p) continue; |
| if ((size - 2) == k) { |
| size = size * 11 / 10; |
| kcand = xrealloc(kcand, (size*sizeof(struct candidate *))); |
| } |
| do_merge(kcand, &k, i, e, e[i].p); |
| } |
| free(v[0]); //no need for v_vector now. |
| free(v[1]); |
| |
| J = xzalloc((TT.file[0].len+2)*sizeof(int)); |
| |
| for (pr = kcand[k]; pr; pr = pr->prev) J[pr->a] = pr->b; |
| J[TT.file[0].len+1] = TT.file[1].len+1; //mark boundary |
| |
| for (i = k+1; i>=0; i--) llist_traverse(kcand[i], free); |
| free(kcand); |
| |
| for (i = 1; i<=TT.file[0].len; i++) { // jackpot? |
| if (!J[i]) continue; |
| |
| if (fseek(TT.file[0].fp, TT.offset[0][i-1], SEEK_SET) |
| || fseek(TT.file[1].fp, TT.offset[1][J[i]-1], SEEK_SET)) |
| perror_exit("fseek"); |
| |
| for (j = J[i]; i<=TT.file[0].len && J[i]==j; i++, j++) { |
| int tok0 = 0, tok1 = 0; |
| |
| do { |
| tok0 = read_tok(TT.file[0].fp, NULL, tok0); |
| tok1 = read_tok(TT.file[1].fp, NULL, tok1); |
| if (((tok0 ^ tok1) & empty) || ((tok0 & 0xff) != (tok1 & 0xff))) |
| J[i] = 0; |
| } while (!(tok0 & tok1 & empty)); |
| } |
| } |
| return J; |
| } |
| |
| static int *diff(char **files) |
| { |
| size_t i ,j; |
| int s, t; |
| char *bufi, *bufj; |
| |
| TT.is_binary = 0; //loop calls to diff |
| TT.differ = 0; |
| |
| for (i = 0; i < 2; i++) { |
| if ((j = !strcmp(files[i], "-")) || S_ISFIFO(TT.st[i].st_mode)) { |
| char *tmp_name; |
| int srcfd = j ? 0 : open(files[i], O_RDONLY), |
| tmpfd = xtempfile("fifo", &tmp_name); |
| |
| unlink(tmp_name); |
| free(tmp_name); |
| |
| xsendfile(srcfd, tmpfd); |
| if (!j) close(srcfd); |
| TT.file[i].fp = fdopen(tmpfd, "r"); |
| } else TT.file[i].fp = fopen(files[i], "r"); |
| |
| if (!TT.file[i].fp) { |
| perror_msg("%s", files[i]); |
| TT.differ = 2; |
| return 0; //return SAME |
| } |
| } |
| |
| s = sizeof(toybuf)/2; |
| bufi = toybuf; |
| bufj = toybuf+s; |
| |
| if (fseek(TT.file[0].fp, 0, SEEK_SET) || fseek(TT.file[1].fp, 0, SEEK_SET)) |
| perror_exit("fseek"); |
| |
| if (FLAG(a)) return create_j_vector(); |
| |
| while (1) { |
| i = fread(bufi, 1, s, TT.file[0].fp); |
| j = fread(bufj, 1, s, TT.file[1].fp); |
| |
| if (i != j) TT.differ = 1; |
| |
| for (t = 0; t < i && !TT.is_binary; t++) if (!bufi[t]) TT.is_binary = 1; |
| for (t = 0; t < j && !TT.is_binary; t++) if (!bufj[t]) TT.is_binary = 1; |
| |
| i = minof(i, j); |
| for (t = 0; t < i; t++) if (bufi[t] != bufj[t]) TT.differ = 1; |
| |
| if (!i || !j) break; |
| } |
| if (TT.is_binary || !TT.differ) return 0; |
| |
| return create_j_vector(); |
| } |
| |
| static void print_line_matching_regex(int a, regex_t *reg, int *off_set, FILE *fp) { |
| int i = 0, j = 0, line_buf_size = 100, cc = 0; |
| char* line = xzalloc(line_buf_size * sizeof(char)); |
| for (i = a; a > 0; --i) { |
| int line_len = 0; |
| if (fseek(fp, off_set[i - 1], SEEK_SET)) perror_exit("fseek failed"); |
| for (j = 0; j < (off_set[i] - off_set[i - 1]); j++) { |
| cc = fgetc(fp); |
| if (cc == EOF || cc == '\n') { |
| break; |
| } |
| ++line_len; |
| if (line_len >= line_buf_size) { |
| line_buf_size = line_buf_size * 11 / 10; |
| line = xrealloc(line, line_buf_size*sizeof(char)); |
| } |
| line[j] = cc; |
| } |
| line[line_len] = '\0'; |
| if (!regexec0(reg, line, line_len, 0, NULL, 0)) { |
| printf(" %s", line); |
| break; |
| } |
| } |
| free(line); |
| } |
| |
| static void print_diff(int a, int b, char c, int *off_set, FILE *fp) |
| { |
| int i, j, cc, cl; |
| char *reset = 0, *fmt = 0; |
| |
| if (!TT.new_line_format && c!=' ' && FLAG(color)) { |
| printf("\e[%dm", 31+(c=='+')); |
| reset = "\e[0m"; |
| } |
| |
| for (i = a; i <= b; i++) { |
| if (fseek(fp, off_set[i - 1], SEEK_SET)) perror_exit("fseek failed"); |
| if (TT.new_line_format) { |
| if (c == '+') fmt = TT.new_line_format; |
| else if (c == '-') fmt = TT.old_line_format; |
| else fmt = TT.unchanged_line_format; |
| while (*fmt) { |
| if (*fmt == '%') { |
| fmt++; |
| char f = *fmt++; |
| if (f == '%') putchar('%'); |
| else if (f == 'l' || f == 'L') { |
| for (j = 0; j < (off_set[i] - off_set[i - 1]); j++) { |
| cc = fgetc(fp); |
| if (cc == EOF) break; |
| if (cc != '\n' || f == 'L') putchar(cc); |
| } |
| } else error_exit("Unrecognized format specifier %%%c", f); |
| } else putchar(*fmt++); |
| } |
| continue; |
| } |
| putchar(c); |
| if (FLAG(T)) putchar('\t'); |
| for (j = 0, cl = 0; j < (off_set[i] - off_set[i - 1]); j++) { |
| cc = fgetc(fp); |
| if (cc == EOF) { |
| printf("%s\n\\ No newline at end of file\n", reset ? : ""); |
| return; |
| } |
| if ((cc == '\t') && FLAG(t)) do putchar(' '); while (++cl & 7); |
| else { |
| putchar(cc); //xputc has calls to fflush, it hurts performance badly. |
| cl++; |
| } |
| } |
| } |
| if (reset) xputsn(reset); |
| } |
| |
| static char *concat_file_path(char *path, char *default_path) |
| { |
| char *final_path; |
| |
| if ('/' == path[strlen(path) - 1]) { |
| while (*default_path == '/') ++default_path; |
| final_path = xmprintf("%s%s", path, default_path); |
| } |
| else if (*default_path != '/') |
| final_path = xmprintf("%s/%s", path, default_path); |
| else final_path = xmprintf("%s%s", path, default_path); |
| return final_path; |
| } |
| |
| static int skip(struct dirtree *node) |
| { |
| int len = strlen(toys.optargs[TT.dir_num]), ret = 0; |
| char *tmp = NULL, *ptr, *f_path = dirtree_path(node, NULL); |
| struct stat st; |
| |
| ptr = f_path; |
| ptr += len; |
| if (ptr[0]) { |
| tmp = concat_file_path(toys.optargs[1 - TT.dir_num], ptr); |
| if (tmp && !stat(tmp, &st)) ret = 0; //it is there on other side |
| else ret = 1; //not present on other side. |
| } |
| free(f_path); |
| if (tmp) free(tmp); |
| return ret; //add otherwise |
| } |
| |
| static void add_to_list(struct dirtree *node) |
| { |
| char *full_path; |
| |
| TT.dir[TT.dir_num].list = xrealloc(TT.dir[TT.dir_num].list, |
| (TT.size + 1)*sizeof(char*)); |
| TT.size++; |
| full_path = dirtree_path(node, NULL); |
| TT.dir[TT.dir_num].list[TT.size - 1] = full_path; |
| } |
| |
| static int list_dir(struct dirtree *node) |
| { |
| int ret = 0; |
| |
| if (!dirtree_notdotdot(node)) return 0; |
| |
| if (S_ISDIR(node->st.st_mode) && !node->parent) { //add root dirs. |
| add_to_list(node); |
| return (DIRTREE_RECURSE|DIRTREE_SYMFOLLOW); |
| } |
| |
| if (S_ISDIR(node->st.st_mode) && FLAG(r)) { |
| if (!FLAG(N)) ret = skip(node); |
| if (!ret) return DIRTREE_RECURSE|DIRTREE_SYMFOLLOW; |
| else { |
| add_to_list(node); //only at one side. |
| return 0; |
| } |
| } else { |
| add_to_list(node); |
| return S_ISDIR(node->st.st_mode) ? 0 : (DIRTREE_RECURSE|DIRTREE_SYMFOLLOW); |
| } |
| } |
| |
| static int cmp(void *p1, void *p2) |
| { |
| return strcmp(*(char **)p1, *(char **)p2); |
| } |
| |
| // quote and escape filenames that have awkward characters |
| char *quote_filename(char *filename) |
| { |
| char *to = "abfnrtv\"\\", *from = "\a\b\f\n\r\t\v\"\\", *s, *t=0, *u; |
| int len, quote = 0; |
| |
| for (;;) { |
| // measure escapes on first pass, write on second |
| len = 0; |
| for (s = filename; *s; s++) { |
| if ((u = strchr(from, *s))) { |
| if (t) t[len] = '\\', t[len+1] = to[u-from]; |
| len += 2; |
| } else if (*s<0x20 || *s>=0x80) |
| len += snprintf(t+len, 5*!!t, "\\%.3o", *s); |
| else { |
| if (t) t[len] = *s; |
| len++; |
| } |
| } |
| if (t) { |
| if (quote) t[len++] = '"'; |
| t[len] = 0; |
| |
| return t-quote; |
| } |
| |
| // construct the new string |
| quote = strlen(filename)!=len || strchr(filename, ' '); |
| t = xmalloc(len+1+2*quote); |
| if (quote) *t++ = '"'; |
| } |
| } |
| |
| static void show_label(char *prefix, char *filename, struct stat *sb) |
| { |
| char date[36]; |
| char *quoted_file; |
| |
| quoted_file = quote_filename(filename); |
| printf("%s %s\t%s\n", prefix, quoted_file, |
| format_iso_time(date, sizeof(date), &sb->st_mtim)); |
| free(quoted_file); |
| } |
| |
| static void do_diff(char **files) |
| { |
| long i = 1, size = 1, x = 0, change = 0, ignore_white, |
| start1, end1, start2, end2; |
| struct diff *d; |
| struct arg_list *llist = TT.L; |
| int *J; |
| regex_t reg; |
| |
| TT.offset[0] = TT.offset[1] = NULL; |
| J = diff(files); |
| |
| if (!J) return; //No need to compare, have to status only |
| |
| if (TT.F) { |
| xregcomp(®, TT.F, 0); |
| } |
| |
| d = xzalloc(size *sizeof(struct diff)); |
| do { |
| ignore_white = 0; |
| for (d[x].a = i; d[x].a<=TT.file[0].len; d[x].a++) { |
| if (J[d[x].a] != (J[d[x].a - 1] + 1)) break; |
| else continue; |
| } |
| d[x].c = (J[d[x].a - 1] + 1); |
| |
| for (d[x].b = (d[x].a - 1); d[x].b<=TT.file[0].len; d[x].b++) { |
| if (J[d[x].b + 1]) break; |
| else continue; |
| } |
| d[x].d = (J[d[x].b + 1] - 1); |
| |
| if (FLAG(B)) { |
| if (d[x].a <= d[x].b) { |
| if ((TT.offset[0][d[x].b] - TT.offset[0][d[x].a - 1]) |
| == (d[x].b - d[x].a + 1)) |
| ignore_white = 1; |
| } else if (d[x].c <= d[x].d){ |
| if ((TT.offset[1][d[x].d] - TT.offset[1][d[x].c - 1]) |
| == (d[x].d - d[x].c + 1)) |
| ignore_white = 1; |
| } |
| } |
| |
| //is we have diff ? TODO: lolcat? |
| if ((d[x].a <= d[x].b || d[x].c <= d[x].d) && !ignore_white) change = 1; |
| |
| if (!ignore_white) d = xrealloc(d, (x + 2) *sizeof(struct diff)); |
| i = d[x].b + 1; |
| if (i>TT.file[0].len) break; |
| J[d[x].b] = d[x].d; |
| if (!ignore_white) x++; |
| } while (i<=TT.file[0].len); |
| |
| i = x+1; |
| TT.differ = change; //update status, may change bcoz of -w etc. |
| |
| if (!FLAG(q) && change) { |
| if (!TT.new_line_format) { |
| if (FLAG(color)) printf("\e[1m"); |
| if (FLAG(L)) printf("--- %s\n", llist->arg); |
| else show_label("---", files[0], &(TT).st[0]); |
| if (!FLAG(L) || !llist->next) show_label("+++", files[1], &(TT).st[1]); |
| else { |
| while (llist->next) llist = llist->next; |
| printf("+++ %s\n", llist->arg); |
| } |
| if (FLAG(color)) printf("\e[0m"); |
| } |
| |
| struct diff *t, *ptr1 = d, *ptr2 = d; |
| while (i) { |
| long a,b; |
| |
| // trim context to file len. |
| if (TT.new_line_format || TT.U>TT.file[0].len) TT.U = TT.file[0].len; |
| if (ptr1->b < ptr1->a && ptr1->d < ptr1->c) { |
| i--; |
| continue; |
| } |
| //Handle the context stuff |
| a = ptr1->a; |
| b = minof(TT.file[0].len, ptr1->b); |
| if (i == x + 1) ptr1->suff = maxof(1, a-TT.U); |
| else if (ptr1[-1].prev >= ptr1->a-TT.U) ptr1->suff = ptr1[-1].prev+1; |
| else ptr1->suff = ptr1->a-TT.U; |
| calc_ct: |
| if (i > 1) { |
| if ((ptr2->b + TT.U) >= (ptr2 + 1)->a) { |
| ptr2++; |
| i--; |
| goto calc_ct; |
| } else ptr2->prev = ptr2->b + TT.U; |
| } else ptr2->prev = ptr2->b; |
| start1 = (ptr2->prev - ptr1->suff + 1); |
| end1 = (start1 == 1) ? -1 : start1; |
| start2 = maxof(1, ptr1->c - (ptr1->a - ptr1->suff)); |
| end2 = ptr2->prev - ptr2->b + ptr2->d; |
| |
| if (!TT.new_line_format) { |
| if (FLAG(color)) printf("\e[36m"); |
| printf("@@ -%ld", start1 ? ptr1->suff: (ptr1->suff -1)); |
| if (end1 != -1) printf(",%ld ", ptr2->prev-ptr1->suff + 1); |
| else putchar(' '); |
| |
| printf("+%ld", (end2 - start2 + 1) ? start2: (start2 -1)); |
| if ((end2 - start2 +1) != 1) printf(",%ld ", (end2 - start2 +1)); |
| else putchar(' '); |
| printf("@@"); |
| if (FLAG(color)) printf("\e[0m"); |
| if (TT.F) { |
| print_line_matching_regex(ptr1->suff-1, ®, TT.offset[0], TT.file[0].fp); |
| } |
| putchar('\n'); |
| } |
| |
| for (t = ptr1; t <= ptr2; t++) { |
| if (t==ptr1) print_diff(t->suff, t->a-1, ' ', TT.offset[0], TT.file[0].fp); |
| print_diff(t->a, t->b, '-', TT.offset[0], TT.file[0].fp); |
| print_diff(t->c, t->d, '+', TT.offset[1], TT.file[1].fp); |
| if (t == ptr2) |
| print_diff(t->b+1, (t)->prev, ' ', TT.offset[0], TT.file[0].fp); |
| else print_diff(t->b+1, (t+1)->a-1, ' ', TT.offset[0], TT.file[0].fp); |
| } |
| ptr2++; |
| ptr1 = ptr2; |
| i--; |
| } //end of while |
| } //End of !FLAG_q |
| free(d); |
| free(J); |
| free(TT.offset[0]); |
| free(TT.offset[1]); |
| } |
| |
| static void show_status(char **files) |
| { |
| if (TT.differ==2) return; // TODO: needed? |
| if (TT.differ ? FLAG(q) || TT.is_binary : FLAG(s)) |
| printf("Files %s and %s %s\n", files[0], files[1], |
| TT.differ ? "differ" : "are identical"); |
| } |
| |
| static void create_empty_entry(int l , int r, int j) |
| { |
| struct stat st[2]; |
| char *f[2], *path[2]; |
| int i; |
| |
| for (i = 0; i < 2; i++) { |
| if (j) { |
| if (!FLAG(N) || i!=(j>0)) continue; |
| path[!i] = concat_file_path(TT.dir[!i].list[0], |
| TT.dir[i].list[i ? r : l]+TT.len[i]); |
| f[!i] = "/dev/null"; |
| } |
| path[i] = f[i] = TT.dir[i].list[i ? r : l]; |
| stat(f[i], st+i); |
| if (j) st[!i] = st[i]; |
| } |
| |
| for (i = 0; i<2; i++) { |
| if (!S_ISREG(st[i].st_mode) && !S_ISDIR(st[i].st_mode)) { |
| printf("File %s is not a regular file or directory and was skipped\n", |
| path[i]); |
| break; |
| } |
| } |
| |
| if (i != 2); |
| else if (S_ISDIR(st[0].st_mode) && S_ISDIR(st[1].st_mode)) |
| printf("Common subdirectories: %s and %s\n", path[0], path[1]); |
| else if ((i = S_ISDIR(st[0].st_mode)) != S_ISDIR(st[1].st_mode)) { |
| char *fidir[] = {"directory", "regular file"}; |
| printf("File %s is a %s while file %s is a %s\n", |
| path[0], fidir[!i], path[1], fidir[i]); |
| } else { |
| do_diff(f); |
| show_status(path); |
| if (TT.file[0].fp) fclose(TT.file[0].fp); |
| if (TT.file[1].fp) fclose(TT.file[1].fp); |
| } |
| |
| if (FLAG(N) && j) free(path[j<=0]); |
| } |
| |
| static void diff_dir(int *start) |
| { |
| int l, r, j = 0; |
| |
| l = start[0]; //left side file start |
| r = start[1]; //right side file start |
| while (l < TT.dir[0].nr_elm && r < TT.dir[1].nr_elm) { |
| if ((j = strcmp (TT.dir[0].list[l]+TT.len[0], |
| (TT.dir[1].list[r]+TT.len[1]))) && !FLAG(N)) { |
| if (j > 0) { |
| printf("Only in %s: %s\n", TT.dir[1].list[0], TT.dir[1].list[r]+TT.len[1]); |
| free(TT.dir[1].list[r++]); |
| } else { |
| printf ("Only in %s: %s\n", TT.dir[0].list[0], TT.dir[0].list[l]+TT.len[0]); |
| free(TT.dir[0].list[l++]); |
| } |
| TT.differ = 1; |
| } else { |
| create_empty_entry(l, r, j); //create non empty dirs/files if -N. |
| if (j>=0) free(TT.dir[1].list[r++]); |
| if (j<=0) free(TT.dir[0].list[l++]); |
| } |
| } |
| |
| if (l == TT.dir[0].nr_elm) { |
| while (r<TT.dir[1].nr_elm) { |
| if (!FLAG(N)) { |
| printf ("Only in %s: %s\n", TT.dir[1].list[0], TT.dir[1].list[r]+TT.len[1]); |
| TT.differ = 1; |
| } else create_empty_entry(l, r, 1); |
| free(TT.dir[1].list[r++]); |
| } |
| } else if (r == TT.dir[1].nr_elm) { |
| while (l<TT.dir[0].nr_elm) { |
| if (!FLAG(N)) { |
| printf ("Only in %s: %s\n", TT.dir[0].list[0], TT.dir[0].list[l]+TT.len[0]); |
| TT.differ = 1; |
| } else create_empty_entry(l, r, -1); |
| free(TT.dir[0].list[l++]); |
| } |
| } |
| free(TT.dir[0].list[0]); //we are done, free root nodes too |
| free(TT.dir[0].list); |
| free(TT.dir[1].list[0]); |
| free(TT.dir[1].list); |
| } |
| |
| void diff_main(void) |
| { |
| int j = 0, k = 1, start[2] = {1, 1}; |
| char **files = toys.optargs; |
| |
| toys.exitval = 2; |
| if (FLAG(color) && !isatty(1)) toys.optflags ^= FLAG_color; |
| |
| for (j = 0; j < 2; j++) { |
| if (IS_STDIN(files[j])) fstat(0, &TT.st[j]); |
| else xstat(files[j], &TT.st[j]); |
| } |
| |
| if (S_ISDIR(TT.st[0].st_mode) != S_ISDIR(TT.st[1].st_mode)) |
| error_exit("can't compare directory to non-directory"); |
| |
| if (TT.unchanged_line_format || TT.old_line_format || TT.new_line_format) { |
| if (S_ISDIR(TT.st[0].st_mode) && S_ISDIR(TT.st[1].st_mode)) |
| error_exit("can't use line format with directories"); |
| if (!TT.unchanged_line_format) TT.unchanged_line_format = "%l\n"; |
| if (!TT.old_line_format) TT.old_line_format = "%l\n"; |
| if (!TT.new_line_format) TT.new_line_format = "%l\n"; |
| } |
| |
| if (same_file(TT.st, TT.st+1)) { |
| toys.exitval = 0; |
| return show_status(files); |
| } |
| |
| if (S_ISDIR(TT.st[0].st_mode) && S_ISDIR(TT.st[1].st_mode)) { |
| for (j = 0; j < 2; j++) { |
| memset(TT.dir+j, 0, sizeof(*TT.dir)); |
| dirtree_flagread(files[j], DIRTREE_SYMFOLLOW, list_dir); |
| TT.dir[j].nr_elm = TT.size; //size updated in list_dir |
| qsort(&TT.dir[j].list[1], TT.size-1, sizeof(char *), (void *)cmp); |
| |
| TT.len[j] = strlen(TT.dir[j].list[0]); //calc root node len |
| TT.len[j] += TT.dir[j].list[0][TT.len[j]-1] != '/'; |
| |
| if (FLAG(S)) { |
| while (k<TT.size && strcmp(TT.dir[j].list[k]+TT.len[j], TT.S)<0) { |
| start[j]++; |
| k++; |
| } |
| } |
| TT.dir_num++; |
| TT.size = 0; |
| k = 1; |
| } |
| diff_dir(start); |
| } else { |
| if (S_ISDIR(TT.st[0].st_mode) || S_ISDIR(TT.st[1].st_mode)) { |
| int d = S_ISDIR(TT.st[0].st_mode); |
| char *slash = strrchr(files[d], '/'); |
| |
| files[!d] = concat_file_path(files[!d], slash ? slash+1 : files[d]); |
| if (stat(files[!d], &TT.st[!d])) perror_exit("%s", files[!d]); |
| } |
| do_diff(files); |
| show_status(files); |
| if (TT.file[0].fp) fclose(TT.file[0].fp); |
| if (TT.file[1].fp) fclose(TT.file[1].fp); |
| } |
| toys.exitval = TT.differ; //exit status will be the status |
| } |