#include "git-compat-util.h"

#include "line-range.h"

#include "cache.h"

#include "tag.h"

#include "blob.h"

#include "tree.h"

#include "diff.h"

#include "commit.h"

#include "decorate.h"

#include "revision.h"

#include "xdiff-interface.h"

#include "strbuf.h"

#include "log-tree.h"

#include "graph.h"

#include "userdiff.h"

#include "line-log.h"

#include "argv-array.h"

static void range_set_grow(struct range_set *rs, size_t extra)

{

	ALLOC_GROW(rs->ranges, rs->nr + extra, rs->alloc);

}

/* Either initialization would be fine */

#define RANGE_SET_INIT {0}

void range_set_init(struct range_set *rs, size_t prealloc)

{

	rs->alloc = rs->nr = 0;

	rs->ranges = NULL;

	if (prealloc)

		range_set_grow(rs, prealloc);

}

void range_set_release(struct range_set *rs)

{

	FREE_AND_NULL(rs->ranges);

	rs->alloc = rs->nr = 0;

}

/* dst must be uninitialized! */

static void range_set_copy(struct range_set *dst, struct range_set *src)

{

	range_set_init(dst, src->nr);

	COPY_ARRAY(dst->ranges, src->ranges, src->nr);

	dst->nr = src->nr;

}

static void range_set_move(struct range_set *dst, struct range_set *src)

{

	range_set_release(dst);

	dst->ranges = src->ranges;

	dst->nr = src->nr;

	dst->alloc = src->alloc;

	src->ranges = NULL;

	src->alloc = src->nr = 0;

}

/* tack on a _new_ range _at the end_ */

void range_set_append_unsafe(struct range_set *rs, long a, long b)

{

	assert(a <= b);

	range_set_grow(rs, 1);

	rs->ranges[rs->nr].start = a;

	rs->ranges[rs->nr].end = b;

	rs->nr++;

}

void range_set_append(struct range_set *rs, long a, long b)

{

	assert(rs->nr == 0 || rs->ranges[rs->nr-1].end <= a);

	range_set_append_unsafe(rs, a, b);

}

static int range_cmp(const void *_r, const void *_s)

{

	const struct range *r = _r;

	const struct range *s = _s;

	/* this could be simply 'return r.start-s.start', but for the types */

	if (r->start == s->start)

		return 0;

	if (r->start < s->start)

		return -1;

	return 1;

}

/*

 * Check that the ranges are non-empty, sorted and non-overlapping

 */

static void range_set_check_invariants(struct range_set *rs)

{

	unsigned int i;

	if (!rs)

		return;

	if (rs->nr)

		assert(rs->ranges[0].start < rs->ranges[0].end);

	for (i = 1; i < rs->nr; i++) {

		assert(rs->ranges[i-1].end < rs->ranges[i].start);

		assert(rs->ranges[i].start < rs->ranges[i].end);

	}

}

/*

 * In-place pass of sorting and merging the ranges in the range set,

 * to establish the invariants when we get the ranges from the user

 */

void sort_and_merge_range_set(struct range_set *rs)

{

	unsigned int i;

	unsigned int o = 0; /* output cursor */

	QSORT(rs->ranges, rs->nr, range_cmp);

	for (i = 0; i < rs->nr; i++) {

		if (rs->ranges[i].start == rs->ranges[i].end)

			continue;

		if (o > 0 && rs->ranges[i].start <= rs->ranges[o-1].end) {

			if (rs->ranges[o-1].end < rs->ranges[i].end)

				rs->ranges[o-1].end = rs->ranges[i].end;

		} else {

			rs->ranges[o].start = rs->ranges[i].start;

			rs->ranges[o].end = rs->ranges[i].end;

			o++;

		}

	}

	assert(o <= rs->nr);

	rs->nr = o;

	range_set_check_invariants(rs);

}

/*

 * Union of range sets (i.e., sets of line numbers).  Used to merge

 * them when searches meet at a common ancestor.

 *

 * This is also where the ranges are consolidated into canonical form:

 * overlapping and adjacent ranges are merged, and empty ranges are

 * removed.

 */

static void range_set_union(struct range_set *out,

			     struct range_set *a, struct range_set *b)

{

	unsigned int i = 0, j = 0;

	struct range *ra = a->ranges;

	struct range *rb = b->ranges;

	/* cannot make an alias of out->ranges: it may change during grow */

	assert(out->nr == 0);

	while (i < a->nr || j < b->nr) {

		struct range *new_range;

		if (i < a->nr && j < b->nr) {

			if (ra[i].start < rb[j].start)

				new_range = &ra[i++];

			else if (ra[i].start > rb[j].start)

				new_range = &rb[j++];

			else if (ra[i].end < rb[j].end)

				new_range = &ra[i++];

			else

				new_range = &rb[j++];

		} else if (i < a->nr)      /* b exhausted */

			new_range = &ra[i++];

		else                       /* a exhausted */

			new_range = &rb[j++];

		if (new_range->start == new_range->end)

			; /* empty range */

		else if (!out->nr || out->ranges[out->nr-1].end < new_range->start) {

			range_set_grow(out, 1);

			out->ranges[out->nr].start = new_range->start;

			out->ranges[out->nr].end = new_range->end;

			out->nr++;

		} else if (out->ranges[out->nr-1].end < new_range->end) {

			out->ranges[out->nr-1].end = new_range->end;

		}

	}

}

/*

 * Difference of range sets (out = a \ b).  Pass the "interesting"

 * ranges as 'a' and the target side of the diff as 'b': it removes

 * the ranges for which the commit is responsible.

 */

static void range_set_difference(struct range_set *out,

				  struct range_set *a, struct range_set *b)

{

	unsigned int i, j =  0;

	for (i = 0; i < a->nr; i++) {

		long start = a->ranges[i].start;

		long end = a->ranges[i].end;

		while (start < end) {

			while (j < b->nr && start >= b->ranges[j].end)

				/*

				 * a:         |-------

				 * b: ------|

				 */

				j++;

			if (j >= b->nr || end < b->ranges[j].start) {

				/*

				 * b exhausted, or

				 * a:  ----|

				 * b:         |----

				 */

				range_set_append(out, start, end);

				break;

			}

			if (start >= b->ranges[j].start) {

				/*

				 * a:     |--????

				 * b: |------|

				 */

				start = b->ranges[j].end;

			} else if (end > b->ranges[j].start) {

				/*

				 * a: |-----|

				 * b:    |--?????

				 */

				if (start < b->ranges[j].start)

					range_set_append(out, start, b->ranges[j].start);

				start = b->ranges[j].end;

			}

		}

	}

}

static void diff_ranges_init(struct diff_ranges *diff)

{

	range_set_init(&diff->parent, 0);

	range_set_init(&diff->target, 0);

}

static void diff_ranges_release(struct diff_ranges *diff)

{

	range_set_release(&diff->parent);

	range_set_release(&diff->target);

}

static void line_log_data_init(struct line_log_data *r)

{

	memset(r, 0, sizeof(struct line_log_data));

	range_set_init(&r->ranges, 0);

}

static void line_log_data_clear(struct line_log_data *r)

{

	range_set_release(&r->ranges);

	if (r->pair)

		diff_free_filepair(r->pair);

}

static void free_line_log_data(struct line_log_data *r)

{

	while (r) {

		struct line_log_data *next = r->next;

		line_log_data_clear(r);

		free(r);

		r = next;

	}

}

static struct line_log_data *

search_line_log_data(struct line_log_data *list, const char *path,

		     struct line_log_data **insertion_point)

{

	struct line_log_data *p = list;

	if (insertion_point)

		*insertion_point = NULL;

	while (p) {

		int cmp = strcmp(p->path, path);

		if (!cmp)

			return p;

		if (insertion_point && cmp < 0)

			*insertion_point = p;

		p = p->next;

	}

	return NULL;

}

/*

 * Note: takes ownership of 'path', which happens to be what the only

 * caller needs.

 */

static void line_log_data_insert(struct line_log_data **list,

				 char *path,

				 long begin, long end)

{

	struct line_log_data *ip;

	struct line_log_data *p = search_line_log_data(*list, path, &ip);

	if (p) {

		range_set_append_unsafe(&p->ranges, begin, end);

		free(path);

		return;

	}

	p = xcalloc(1, sizeof(struct line_log_data));

	p->path = path;

	range_set_append(&p->ranges, begin, end);

	if (ip) {

		p->next = ip->next;

		ip->next = p;

	} else {

		p->next = *list;

		*list = p;

	}

}

struct collect_diff_cbdata {

	struct diff_ranges *diff;

};

static int collect_diff_cb(long start_a, long count_a,

			   long start_b, long count_b,

			   void *data)

{

	struct collect_diff_cbdata *d = data;

	if (count_a >= 0)

		range_set_append(&d->diff->parent, start_a, start_a + count_a);

	if (count_b >= 0)

		range_set_append(&d->diff->target, start_b, start_b + count_b);

	return 0;

}

static int collect_diff(mmfile_t *parent, mmfile_t *target, struct diff_ranges *out)

{

	struct collect_diff_cbdata cbdata = {NULL};

	xpparam_t xpp;

	xdemitconf_t xecfg;

	xdemitcb_t ecb;

	memset(&xpp, 0, sizeof(xpp));

	memset(&xecfg, 0, sizeof(xecfg));

	xecfg.ctxlen = xecfg.interhunkctxlen = 0;

	cbdata.diff = out;

	xecfg.hunk_func = collect_diff_cb;

	memset(&ecb, 0, sizeof(ecb));

	ecb.priv = &cbdata;

	return xdi_diff(parent, target, &xpp, &xecfg, &ecb;;

}

/*

 * These are handy for debugging.  Removing them with #if 0 silences

 * the "unused function" warning.

 */

#if 0

static void dump_range_set(struct range_set *rs, const char *desc)

{

	int i;

	printf("range set %s (%d items):\n", desc, rs->nr);

	for (i = 0; i < rs->nr; i++)

		printf("\t[%ld,%ld]\n", rs->ranges[i].start, rs->ranges[i].end);

}

static void dump_line_log_data(struct line_log_data *r)

{

	char buf[4096];

	while (r) {

		snprintf(buf, 4096, "file %s\n", r->path);

		dump_range_set(&r->ranges, buf);

		r = r->next;

	}

}

static void dump_diff_ranges(struct diff_ranges *diff, const char *desc)

{

	int i;

	assert(diff->parent.nr == diff->target.nr);

	printf("diff ranges %s (%d items):\n", desc, diff->parent.nr);

	printf("\tparent\ttarget\n");

	for (i = 0; i < diff->parent.nr; i++) {

		printf("\t[%ld,%ld]\t[%ld,%ld]\n",

		       diff->parent.ranges[i].start,

		       diff->parent.ranges[i].end,

		       diff->target.ranges[i].start,

		       diff->target.ranges[i].end);

	}

}

#endif

static int ranges_overlap(struct range *a, struct range *b)

{

	return !(a->end <= b->start || b->end <= a->start);

}

/*

 * Given a diff and the set of interesting ranges, determine all hunks

 * of the diff which touch (overlap) at least one of the interesting

 * ranges in the target.

 */

static void diff_ranges_filter_touched(struct diff_ranges *out,

				       struct diff_ranges *diff,

				       struct range_set *rs)

{

	unsigned int i, j = 0;

	assert(out->target.nr == 0);

	for (i = 0; i < diff->target.nr; i++) {

		while (diff->target.ranges[i].start > rs->ranges[j].end) {

			j++;

			if (j == rs->nr)

				return;

		}

		if (ranges_overlap(&diff->target.ranges[i], &rs->ranges[j])) {

			range_set_append(&out->parent,

					 diff->parent.ranges[i].start,

					 diff->parent.ranges[i].end);

			range_set_append(&out->target,

					 diff->target.ranges[i].start,

					 diff->target.ranges[i].end);

		}

	}

}

/*

 * Adjust the line counts in 'rs' to account for the lines

 * added/removed in the diff.

 */

static void range_set_shift_diff(struct range_set *out,

				 struct range_set *rs,

				 struct diff_ranges *diff)

{

	unsigned int i, j = 0;

	long offset = 0;

	struct range *src = rs->ranges;

	struct range *target = diff->target.ranges;

	struct range *parent = diff->parent.ranges;

	for (i = 0; i < rs->nr; i++) {

		while (j < diff->target.nr && src[i].start >= target[j].start) {

			offset += (parent[j].end-parent[j].start)

				- (target[j].end-target[j].start);

			j++;

		}

		range_set_append(out, src[i].start+offset, src[i].end+offset);

	}

}

/*

 * Given a diff and the set of interesting ranges, map the ranges

 * across the diff.  That is: observe that the target commit takes

 * blame for all the + (target-side) ranges.  So for every pair of

 * ranges in the diff that was touched, we remove the latter and add

 * its parent side.

 */

static void range_set_map_across_diff(struct range_set *out,

				      struct range_set *rs,

				      struct diff_ranges *diff,

				      struct diff_ranges **touched_out)

{

	struct diff_ranges *touched = xmalloc(sizeof(*touched));

	struct range_set tmp1 = RANGE_SET_INIT;

	struct range_set tmp2 = RANGE_SET_INIT;

	diff_ranges_init(touched);

	diff_ranges_filter_touched(touched, diff, rs);

	range_set_difference(&tmp1, rs, &touched->target);

	range_set_shift_diff(&tmp2, &tmp1, diff);

	range_set_union(out, &tmp2, &touched->parent);

	range_set_release(&tmp1);

	range_set_release(&tmp2);

	*touched_out = touched;

}

static struct commit *check_single_commit(struct rev_info *revs)

{

	struct object *commit = NULL;

	int found = -1;

	int i;

	for (i = 0; i < revs->pending.nr; i++) {

		struct object *obj = revs->pending.objects[i].item;

		if (obj->flags & UNINTERESTING)

			continue;

		obj = deref_tag(revs->repo, obj, NULL, 0);

		if (obj->type != OBJ_COMMIT)

			die("Non commit %s?", revs->pending.objects[i].name);

		if (commit)

			die("More than one commit to dig from: %s and %s?",

			    revs->pending.objects[i].name,

			    revs->pending.objects[found].name);

		commit = obj;

		found = i;

	}

	if (!commit)

		die("No commit specified?");

	return (struct commit *) commit;

}

static void fill_blob_sha1(struct repository *r, struct commit *commit,

			   struct diff_filespec *spec)

{

	unsigned short mode;

	struct object_id oid;

	if (get_tree_entry(r, &commit->object.oid, spec->path, &oid, &mode))

		die("There is no path %s in the commit", spec->path);

	fill_filespec(spec, &oid, 1, mode);

	return;

}

static void fill_line_ends(struct repository *r,

			   struct diff_filespec *spec,

			   long *lines,

			   unsigned long **line_ends)

{

	int num = 0, size = 50;

	long cur = 0;

	unsigned long *ends = NULL;

	char *data = NULL;

	if (diff_populate_filespec(r, spec, NULL))

		die("Cannot read blob %s", oid_to_hex(&spec->oid));

	ALLOC_ARRAY(ends, size);

	ends[cur++] = 0;

	data = spec->data;

	while (num < spec->size) {

		if (data[num] == '\n' || num == spec->size - 1) {

			ALLOC_GROW(ends, (cur + 1), size);

			ends[cur++] = num;

		}

		num++;

	}

	/* shrink the array to fit the elements */

	REALLOC_ARRAY(ends, cur);

	*lines = cur-1;

	*line_ends = ends;

}

struct nth_line_cb {

	struct diff_filespec *spec;

	long lines;

	unsigned long *line_ends;

};

static const char *nth_line(void *data, long line)

{

	struct nth_line_cb *d = data;

	assert(d && line <= d->lines);

	assert(d->spec && d->spec->data);

	if (line == 0)

		return (char *)d->spec->data;

	else

		return (char *)d->spec->data + d->line_ends[line] + 1;

}

static struct line_log_data *

parse_lines(struct repository *r, struct commit *commit,

	    const char *prefix, struct string_list *args)

{

	long lines = 0;

	unsigned long *ends = NULL;

	struct nth_line_cb cb_data;

	struct string_list_item *item;

	struct line_log_data *ranges = NULL;

	struct line_log_data *p;

	for_each_string_list_item(item, args) {

		const char *name_part, *range_part;

		char *full_name;

		struct diff_filespec *spec;

		long begin = 0, end = 0;

		long anchor;

		name_part = skip_range_arg(item->string, r->index);

		if (!name_part || *name_part != ':' || !name_part[1])

			die("-L argument not 'start,end:file' or ':funcname:file': %s",

			    item->string);

		range_part = xstrndup(item->string, name_part - item->string);

		name_part++;

		full_name = prefix_path(prefix, prefix ? strlen(prefix) : 0,

					name_part);

		spec = alloc_filespec(full_name);

		fill_blob_sha1(r, commit, spec);

		fill_line_ends(r, spec, &lines, &ends);

		cb_data.spec = spec;

		cb_data.lines = lines;

		cb_data.line_ends = ends;

		p = search_line_log_data(ranges, full_name, NULL);

		if (p && p->ranges.nr)

			anchor = p->ranges.ranges[p->ranges.nr - 1].end + 1;

		else

			anchor = 1;

		if (parse_range_arg(range_part, nth_line, &cb_data,

				    lines, anchor, &begin, &end,

				    full_name, r->index))

			die("malformed -L argument '%s'", range_part);

		if ((!lines && (begin || end)) || lines < begin)

			die("file %s has only %lu lines", name_part, lines);

		if (begin < 1)

			begin = 1;

		if (end < 1 || lines < end)

			end = lines;

		begin--;

		line_log_data_insert(&ranges, full_name, begin, end);

		free_filespec(spec);

		FREE_AND_NULL(ends);

	}

	for (p = ranges; p; p = p->next)

		sort_and_merge_range_set(&p->ranges);

	return ranges;

}

static struct line_log_data *line_log_data_copy_one(struct line_log_data *r)

{

	struct line_log_data *ret = xmalloc(sizeof(*ret));

	assert(r);

	line_log_data_init(ret);

	range_set_copy(&ret->ranges, &r->ranges);

	ret->path = xstrdup(r->path);

	return ret;

}

static struct line_log_data *

line_log_data_copy(struct line_log_data *r)

{

	struct line_log_data *ret = NULL;

	struct line_log_data *tmp = NULL, *prev = NULL;

	assert(r);

	ret = tmp = prev = line_log_data_copy_one(r);

	r = r->next;

	while (r) {

		tmp = line_log_data_copy_one(r);

		prev->next = tmp;

		prev = tmp;

		r = r->next;

	}

	return ret;

}

/* merge two range sets across files */

static struct line_log_data *line_log_data_merge(struct line_log_data *a,

						 struct line_log_data *b)

{

	struct line_log_data *head = NULL, **pp = &head;

	while (a || b) {

		struct line_log_data *src;

		struct line_log_data *src2 = NULL;

		struct line_log_data *d;

		int cmp;

		if (!a)

			cmp = 1;

		else if (!b)

			cmp = -1;

		else

			cmp = strcmp(a->path, b->path);

		if (cmp < 0) {

			src = a;

			a = a->next;

		} else if (cmp == 0) {

			src = a;

			a = a->next;

			src2 = b;

			b = b->next;

		} else {

			src = b;

			b = b->next;

		}

		d = xmalloc(sizeof(struct line_log_data));

		line_log_data_init(d);

		d->path = xstrdup(src->path);

		*pp = d;

		pp = &d->next;

		if (src2)

			range_set_union(&d->ranges, &src->ranges, &src2->ranges);

		else

			range_set_copy(&d->ranges, &src->ranges);

	}

	return head;

}

static void add_line_range(struct rev_info *revs, struct commit *commit,

			   struct line_log_data *range)

{

	struct line_log_data *old_line = NULL;

	struct line_log_data *new_line = NULL;

	old_line = lookup_decoration(&revs->line_log_data, &commit->object);

	if (old_line && range) {

		new_line = line_log_data_merge(old_line, range);

		free_line_log_data(old_line);

	} else if (range)

		new_line = line_log_data_copy(range);

	if (new_line)

		add_decoration(&revs->line_log_data, &commit->object, new_line);

}

static void clear_commit_line_range(struct rev_info *revs, struct commit *commit)

{

	struct line_log_data *r;

	r = lookup_decoration(&revs->line_log_data, &commit->object);

	if (!r)

		return;

	free_line_log_data(r);

	add_decoration(&revs->line_log_data, &commit->object, NULL);

}

static struct line_log_data *lookup_line_range(struct rev_info *revs,

					       struct commit *commit)

{

	struct line_log_data *ret = NULL;

	struct line_log_data *d;

	ret = lookup_decoration(&revs->line_log_data, &commit->object);

	for (d = ret; d; d = d->next)

		range_set_check_invariants(&d->ranges);

	return ret;

}

static int same_paths_in_pathspec_and_range(struct pathspec *pathspec,

					    struct line_log_data *range)

{

	int i;

	struct line_log_data *r;

	for (i = 0, r = range; i < pathspec->nr && r; i++, r = r->next)

		if (strcmp(pathspec->items[i].match, r->path))

			return 0;

	if (i < pathspec->nr || r)

		/* different number of pathspec items and ranges */

		return 0;

	return 1;

}

static void parse_pathspec_from_ranges(struct pathspec *pathspec,

				       struct line_log_data *range)

{

	struct line_log_data *r;

	struct argv_array array = ARGV_ARRAY_INIT;

	const char **paths;

	for (r = range; r; r = r->next)

		argv_array_push(&array, r->path);

	paths = argv_array_detach(&array);

	parse_pathspec(pathspec, 0, PATHSPEC_PREFER_FULL, "", paths);

	/* strings are now owned by pathspec */

	free(paths);

}

void line_log_init(struct rev_info *rev, const char *prefix, struct string_list *args)

{

	struct commit *commit = NULL;

	struct line_log_data *range;

	commit = check_single_commit(rev);

	range = parse_lines(rev->diffopt.repo, commit, prefix, args);

	add_line_range(rev, commit, range);

	parse_pathspec_from_ranges(&rev->diffopt.pathspec, range);

}

static void move_diff_queue(struct diff_queue_struct *dst,

			    struct diff_queue_struct *src)

{

	assert(src != dst);

	memcpy(dst, src, sizeof(struct diff_queue_struct));

	DIFF_QUEUE_CLEAR(src);

}

static void filter_diffs_for_paths(struct line_log_data *range, int keep_deletions)

{

	int i;

	struct diff_queue_struct outq;

	DIFF_QUEUE_CLEAR(&outq);

	for (i = 0; i < diff_queued_diff.nr; i++) {

		struct diff_filepair *p = diff_queued_diff.queue[i];

		struct line_log_data *rg = NULL;

		if (!DIFF_FILE_VALID(p->two)) {

			if (keep_deletions)

				diff_q(&outq, p);

			else

				diff_free_filepair(p);

			continue;

		}

		for (rg = range; rg; rg = rg->next) {

			if (!strcmp(rg->path, p->two->path))

				break;

		}

		if (rg)

			diff_q(&outq, p);

		else

			diff_free_filepair(p);

	}

	free(diff_queued_diff.queue);

	diff_queued_diff = outq;

}

static inline int diff_might_be_rename(void)

{

	int i;

	for (i = 0; i < diff_queued_diff.nr; i++)

		if (!DIFF_FILE_VALID(diff_queued_diff.queue[i]->one)) {

			/* fprintf(stderr, "diff_might_be_rename found creation of: %s\n", */

			/* 	diff_queued_diff.queue[i]->two->path); */

			return 1;

		}

	return 0;

}

static void queue_diffs(struct line_log_data *range,

			struct diff_options *opt,

			struct diff_queue_struct *queue,

			struct commit *commit, struct commit *parent)

{

	struct object_id *tree_oid, *parent_tree_oid;

	assert(commit);

	tree_oid = get_commit_tree_oid(commit);

	parent_tree_oid = parent ? get_commit_tree_oid(parent) : NULL;

	if (opt->detect_rename &&

	    !same_paths_in_pathspec_and_range(&opt->pathspec, range)) {

		clear_pathspec(&opt->pathspec);

		parse_pathspec_from_ranges(&opt->pathspec, range);

	}

	DIFF_QUEUE_CLEAR(&diff_queued_diff);

	diff_tree_oid(parent_tree_oid, tree_oid, "", opt);

	if (opt->detect_rename && diff_might_be_rename()) {

		/* must look at the full tree diff to detect renames */

		clear_pathspec(&opt->pathspec);

		DIFF_QUEUE_CLEAR(&diff_queued_diff);

		diff_tree_oid(parent_tree_oid, tree_oid, "", opt);

		filter_diffs_for_paths(range, 1);

		diffcore_std(opt);

		filter_diffs_for_paths(range, 0);

	}

	move_diff_queue(queue, &diff_queued_diff);

}

static char *get_nth_line(long line, unsigned long *ends, void *data)

{

	if (line == 0)

		return (char *)data;

	else

		return (char *)data + ends[line] + 1;

}

static void print_line(const char *prefix, char first,

		       long line, unsigned long *ends, void *data,

		       const char *color, const char *reset, FILE *file)

{

	char *begin = get_nth_line(line, ends, data);

	char *end = get_nth_line(line+1, ends, data);