#if defined(FEAT_DIFF) || defined(PROTO)
-#define DB_COUNT 4 /* up to four buffers can be diff'ed */
-
-/*
- * Each diffblock defines where a block of lines starts in each of the buffers
- * and how many lines it occupies in that buffer. When the lines are missing
- * in the buffer the df_count[] is zero. This is all counted in
- * buffer lines.
- * There is always at least one unchanged line in between the diffs.
- * Otherwise it would have been included in the diff above or below it.
- * df_lnum[] + df_count[] is the lnum below the change. When in one buffer
- * lines have been inserted, in the other buffer df_lnum[] is the line below
- * the insertion and df_count[] is zero. When appending lines at the end of
- * the buffer, df_lnum[] is one beyond the end!
- * This is using a linked list, because the number of differences is expected
- * to be reasonable small. The list is sorted on lnum.
- */
-typedef struct diffblock diff_T;
-struct diffblock
-{
- diff_T *df_next;
- linenr_T df_lnum[DB_COUNT]; /* line number in buffer */
- linenr_T df_count[DB_COUNT]; /* nr of inserted/changed lines */
-};
-
-static diff_T *first_diff = NULL;
-
-static buf_T *(diffbuf[DB_COUNT]);
-
-static int diff_invalid = TRUE; /* list of diffs is outdated */
-
static int diff_busy = FALSE; /* ex_diffgetput() is busy */
/* flags obtained from the 'diffopt' option */
#endif
static int diff_buf_idx __ARGS((buf_T *buf));
-static void diff_check_unchanged __ARGS((diff_T *dp));
-static int diff_check_sanity __ARGS((diff_T *dp));
+static int diff_buf_idx_tp __ARGS((buf_T *buf, tabpage_T *tp));
+static void diff_mark_adjust_tp __ARGS((tabpage_T *tp, int idx, linenr_T line1, linenr_T line2, long amount, long amount_after));
+static void diff_check_unchanged __ARGS((tabpage_T *tp, diff_T *dp));
+static int diff_check_sanity __ARGS((tabpage_T *tp, diff_T *dp));
static void diff_redraw __ARGS((int dofold));
static int diff_write __ARGS((buf_T *buf, char_u *fname));
static void diff_file __ARGS((char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff));
#endif
static void diff_read __ARGS((int idx_orig, int idx_new, char_u *fname));
static void diff_copy_entry __ARGS((diff_T *dprev, diff_T *dp, int idx_orig, int idx_new));
-static diff_T *diff_alloc_new __ARGS((diff_T *dprev, diff_T *dp));
+static diff_T *diff_alloc_new __ARGS((tabpage_T *tp, diff_T *dprev, diff_T *dp));
#ifndef USE_CR
# define tag_fgets vim_fgets
#endif
-/*
- * Call this when a new buffer is being edited in the current window. curbuf
- * must already have been set.
- * Marks the current buffer as being part of the diff and requireing updating.
- * This must be done before any autocmd, because a command the uses info
- * about the screen contents.
- */
- void
-diff_new_buffer()
-{
- if (curwin->w_p_diff)
- diff_buf_add(curbuf);
-}
-
/*
* Called when deleting or unloading a buffer: No longer make a diff with it.
- * Also called when 'diff' is reset in the last window showing a diff for a
- * buffer.
*/
void
diff_buf_delete(buf)
buf_T *buf;
{
int i;
+ tabpage_T *tp;
- i = diff_buf_idx(buf);
- if (i != DB_COUNT)
+ for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
{
- diffbuf[i] = NULL;
- diff_invalid = TRUE;
+ i = diff_buf_idx_tp(buf, tp);
+ if (i != DB_COUNT)
+ {
+ tp->tp_diffbuf[i] = NULL;
+ tp->tp_diff_invalid = TRUE;
+ }
}
}
win_T *win;
{
win_T *wp;
+ int i;
if (!win->w_p_diff)
{
if (wp->w_buffer == win->w_buffer && wp->w_p_diff)
break;
if (wp == NULL)
- diff_buf_delete(win->w_buffer);
+ {
+ i = diff_buf_idx(win->w_buffer);
+ if (i != DB_COUNT)
+ {
+ curtab->tp_diffbuf[i] = NULL;
+ curtab->tp_diff_invalid = TRUE;
+ }
+ }
}
else
diff_buf_add(win->w_buffer);
/*
* Add a buffer to make diffs for.
+ * Call this when a new buffer is being edited in the current window where
+ * 'diff' is set.
+ * Marks the current buffer as being part of the diff and requireing updating.
+ * This must be done before any autocmd, because a command may use info
+ * about the screen contents.
*/
void
diff_buf_add(buf)
return; /* It's already there. */
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] == NULL)
+ if (curtab->tp_diffbuf[i] == NULL)
{
- diffbuf[i] = buf;
- diff_invalid = TRUE;
+ curtab->tp_diffbuf[i] = buf;
+ curtab->tp_diff_invalid = TRUE;
return;
}
}
/*
- * Find buffer "buf" in the list of diff buffers.
+ * Find buffer "buf" in the list of diff buffers for the current tab page.
* Return its index or DB_COUNT if not found.
*/
static int
int idx;
for (idx = 0; idx < DB_COUNT; ++idx)
- if (diffbuf[idx] == buf)
+ if (curtab->tp_diffbuf[idx] == buf)
+ break;
+ return idx;
+}
+
+/*
+ * Find buffer "buf" in the list of diff buffers for tab page "tp".
+ * Return its index or DB_COUNT if not found.
+ */
+ static int
+diff_buf_idx_tp(buf, tp)
+ buf_T *buf;
+ tabpage_T *tp;
+{
+ int idx;
+
+ for (idx = 0; idx < DB_COUNT; ++idx)
+ if (tp->tp_diffbuf[idx] == buf)
break;
return idx;
}
/*
- * Mark the diff info as invalid, it will be updated when info is requested.
+ * Mark the diff info involving buffer "buf" as invalid, it will be updated
+ * when info is requested.
*/
void
-diff_invalidate()
+diff_invalidate(buf)
+ buf_T *buf;
{
- if (curwin->w_p_diff)
+ tabpage_T *tp;
+ int i;
+
+ for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
{
- diff_invalid = TRUE;
- diff_redraw(TRUE);
+ i = diff_buf_idx_tp(buf, tp);
+ if (i != DB_COUNT)
+ {
+ tp->tp_diff_invalid = TRUE;
+ if (tp == curtab)
+ diff_redraw(TRUE);
+ }
}
}
/*
- * Called by mark_adjust(): update line numbers.
+ * Called by mark_adjust(): update line numbers in "curbuf".
+ */
+ void
+diff_mark_adjust(line1, line2, amount, amount_after)
+ linenr_T line1;
+ linenr_T line2;
+ long amount;
+ long amount_after;
+{
+ int idx;
+ tabpage_T *tp;
+
+ /* Handle all tab pages that use the current buffer in a diff. */
+ for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
+ {
+ idx = diff_buf_idx_tp(curbuf, tp);
+ if (idx != DB_COUNT)
+ diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after);
+ }
+}
+
+/*
+ * Update line numbers in tab page "tp" for "curbuf" with index "idx".
* This attempts to update the changes as much as possible:
* When inserting/deleting lines outside of existing change blocks, create a
* new change block and update the line numbers in following blocks.
* When inserting/deleting lines in existing change blocks, update them.
*/
- void
-diff_mark_adjust(line1, line2, amount, amount_after)
+ static void
+diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after)
+ tabpage_T *tp;
+ int idx;
linenr_T line1;
linenr_T line2;
long amount;
diff_T *dp;
diff_T *dprev;
diff_T *dnext;
- int idx;
int i;
int inserted, deleted;
int n, off;
linenr_T lnum_deleted = line1; /* lnum of remaining deletion */
int check_unchanged;
- /* Find the index for the current buffer. */
- idx = diff_buf_idx(curbuf);
- if (idx == DB_COUNT)
- return; /* This buffer doesn't have diffs. */
-
if (line2 == MAXLNUM)
{
/* mark_adjust(99, MAXLNUM, 9, 0): insert lines */
}
dprev = NULL;
- dp = first_diff;
+ dp = tp->tp_first_diff;
for (;;)
{
/* If the change is after the previous diff block and before the next
|| dprev->df_lnum[idx] + dprev->df_count[idx] < line1)
&& !diff_busy)
{
- dnext = diff_alloc_new(dprev, dp);
+ dnext = diff_alloc_new(tp, dprev, dp);
if (dnext == NULL)
return;
dnext->df_lnum[idx] = line1;
dnext->df_count[idx] = inserted;
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] != NULL && i != idx)
+ if (tp->tp_diffbuf[i] != NULL && i != idx)
{
if (dprev == NULL)
dnext->df_lnum[i] = line1;
}
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] != NULL && i != idx)
+ if (tp->tp_diffbuf[i] != NULL && i != idx)
{
dp->df_lnum[i] -= off;
dp->df_count[i] += n;
/* Check if inserted lines are equal, may reduce the
* size of the diff. TODO: also check for equal lines
* in the middle and perhaps split the block. */
- diff_check_unchanged(dp);
+ diff_check_unchanged(tp, dp);
}
}
== dp->df_lnum[idx])
{
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] != NULL)
+ if (tp->tp_diffbuf[i] != NULL)
dprev->df_count[i] += dp->df_count[i];
dprev->df_next = dp->df_next;
vim_free(dp);
}
dprev = NULL;
- dp = first_diff;
+ dp = tp->tp_first_diff;
while (dp != NULL)
{
/* All counts are zero, remove this entry. */
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] != NULL && dp->df_count[i] != 0)
+ if (tp->tp_diffbuf[i] != NULL && dp->df_count[i] != 0)
break;
if (i == DB_COUNT)
{
vim_free(dp);
dp = dnext;
if (dprev == NULL)
- first_diff = dnext;
+ tp->tp_first_diff = dnext;
else
dprev->df_next = dnext;
}
}
}
- diff_redraw(TRUE);
- /* Need to recompute the scroll binding, may remove or add filler lines
- * (e.g., when adding lines above w_topline). But it's slow when making
- * many changes, postpone until redrawing. */
- diff_need_scrollbind = TRUE;
+ if (tp == curtab)
+ {
+ diff_redraw(TRUE);
+
+ /* Need to recompute the scroll binding, may remove or add filler
+ * lines (e.g., when adding lines above w_topline). But it's slow when
+ * making many changes, postpone until redrawing. */
+ diff_need_scrollbind = TRUE;
+ }
}
/*
* Allocate a new diff block and link it between "dprev" and "dp".
*/
static diff_T *
-diff_alloc_new(dprev, dp)
+diff_alloc_new(tp, dprev, dp)
+ tabpage_T *tp;
diff_T *dprev;
diff_T *dp;
{
{
dnew->df_next = dp;
if (dprev == NULL)
- first_diff = dnew;
+ tp->tp_first_diff = dnew;
else
dprev->df_next = dnew;
}
* must take care of removing it.
*/
static void
-diff_check_unchanged(dp)
+diff_check_unchanged(tp, dp)
+ tabpage_T *tp;
diff_T *dp;
{
int i_org;
/* Find the first buffers, use it as the original, compare the other
* buffer lines against this one. */
for (i_org = 0; i_org < DB_COUNT; ++i_org)
- if (diffbuf[i_org] != NULL)
+ if (tp->tp_diffbuf[i_org] != NULL)
break;
if (i_org == DB_COUNT) /* safety check */
return;
- if (diff_check_sanity(dp) == FAIL)
+ if (diff_check_sanity(tp, dp) == FAIL)
return;
/* First check lines at the top, then at the bottom. */
/* Copy the line, the next ml_get() will invalidate it. */
if (dir == BACKWARD)
off_org = dp->df_count[i_org] - 1;
- line_org = vim_strsave(ml_get_buf(diffbuf[i_org],
+ line_org = vim_strsave(ml_get_buf(tp->tp_diffbuf[i_org],
dp->df_lnum[i_org] + off_org, FALSE));
if (line_org == NULL)
return;
for (i_new = i_org + 1; i_new < DB_COUNT; ++i_new)
{
- if (diffbuf[i_new] == NULL)
+ if (tp->tp_diffbuf[i_new] == NULL)
continue;
if (dir == BACKWARD)
off_new = dp->df_count[i_new] - 1;
/* if other buffer doesn't have this line, it was inserted */
if (off_new < 0 || off_new >= dp->df_count[i_new])
break;
- if (diff_cmp(line_org, ml_get_buf(diffbuf[i_new],
+ if (diff_cmp(line_org, ml_get_buf(tp->tp_diffbuf[i_new],
dp->df_lnum[i_new] + off_new, FALSE)) != 0)
break;
}
/* Line matched in all buffers, remove it from the diff. */
for (i_new = i_org; i_new < DB_COUNT; ++i_new)
- if (diffbuf[i_new] != NULL)
+ if (tp->tp_diffbuf[i_new] != NULL)
{
if (dir == FORWARD)
++dp->df_lnum[i_new];
* This can happen when the diff program returns invalid results.
*/
static int
-diff_check_sanity(dp)
+diff_check_sanity(tp, dp)
+ tabpage_T *tp;
diff_T *dp;
{
int i;
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] != NULL)
+ if (tp->tp_diffbuf[i] != NULL)
if (dp->df_lnum[i] + dp->df_count[i] - 1
- > diffbuf[i]->b_ml.ml_line_count)
+ > tp->tp_diffbuf[i]->b_ml.ml_line_count)
return FAIL;
return OK;
}
/*
- * Mark all diff buffers for redraw.
+ * Mark all diff buffers in the current tab page for redraw.
*/
static void
diff_redraw(dofold)
/*ARGSUSED*/
void
ex_diffupdate(eap)
- exarg_T *eap;
+ exarg_T *eap; /* can be NULL, it's not used */
{
buf_T *buf;
int idx_orig;
int ok;
/* Delete all diffblocks. */
- diff_clear();
- diff_invalid = FALSE;
+ diff_clear(curtab);
+ curtab->tp_diff_invalid = FALSE;
/* Use the first buffer as the original text. */
for (idx_orig = 0; idx_orig < DB_COUNT; ++idx_orig)
- if (diffbuf[idx_orig] != NULL)
+ if (curtab->tp_diffbuf[idx_orig] != NULL)
break;
if (idx_orig == DB_COUNT)
return;
/* Only need to do something when there is another buffer. */
for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new)
- if (diffbuf[idx_new] != NULL)
+ if (curtab->tp_diffbuf[idx_new] != NULL)
break;
if (idx_new == DB_COUNT)
return;
}
/* Write the first buffer to a tempfile. */
- buf = diffbuf[idx_orig];
+ buf = curtab->tp_diffbuf[idx_orig];
if (diff_write(buf, tmp_orig) == FAIL)
goto theend;
/* Make a difference between the first buffer and every other. */
for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new)
{
- buf = diffbuf[idx_new];
+ buf = curtab->tp_diffbuf[idx_new];
if (buf == NULL)
continue;
if (diff_write(buf, tmp_new) == FAIL)
{
FILE *fd;
diff_T *dprev = NULL;
- diff_T *dp = first_diff;
+ diff_T *dp = curtab->tp_first_diff;
diff_T *dn, *dpl;
long f1, l1, f2, l2;
char_u linebuf[LBUFLEN]; /* only need to hold the diff line */
if (off > 0)
{
for (i = idx_orig; i < idx_new; ++i)
- if (diffbuf[i] != NULL)
+ if (curtab->tp_diffbuf[i] != NULL)
dp->df_lnum[i] -= off;
dp->df_lnum[idx_new] = lnum_new;
dp->df_count[idx_new] = count_new;
off = 0;
}
for (i = idx_orig; i < idx_new + !notset; ++i)
- if (diffbuf[i] != NULL)
+ if (curtab->tp_diffbuf[i] != NULL)
dp->df_count[i] = dpl->df_lnum[i] + dpl->df_count[i]
- dp->df_lnum[i] + off;
else
{
/* Allocate a new diffblock. */
- dp = diff_alloc_new(dprev, dp);
+ dp = diff_alloc_new(curtab, dprev, dp);
if (dp == NULL)
return;
* original buffer, otherwise there would have been a change
* already. */
for (i = idx_orig + 1; i < idx_new; ++i)
- if (diffbuf[i] != NULL)
+ if (curtab->tp_diffbuf[i] != NULL)
diff_copy_entry(dprev, dp, idx_orig, i);
}
notset = FALSE; /* "*dp" has been set */
}
/*
- * Clear the list of diffblocks.
+ * Clear the list of diffblocks for tab page "tp".
*/
void
-diff_clear()
+diff_clear(tp)
+ tabpage_T *tp;
{
diff_T *p, *next_p;
- for (p = first_diff; p != NULL; p = next_p)
+ for (p = tp->tp_first_diff; p != NULL; p = next_p)
{
next_p = p->df_next;
vim_free(p);
}
- first_diff = NULL;
+ tp->tp_first_diff = NULL;
}
/*
win_T *wp;
linenr_T lnum;
{
- int idx; /* index in diffbuf[] for this buffer */
+ int idx; /* index in tp_diffbuf[] for this buffer */
diff_T *dp;
int maxcount;
int i;
buf_T *buf = wp->w_buffer;
int cmp;
- if (diff_invalid)
+ if (curtab->tp_diff_invalid)
ex_diffupdate(NULL); /* update after a big change */
- if (first_diff == NULL || !wp->w_p_diff) /* no diffs at all */
+ if (curtab->tp_first_diff == NULL || !wp->w_p_diff) /* no diffs at all */
return 0;
/* safety check: "lnum" must be a buffer line */
#endif
/* search for a change that includes "lnum" in the list of diffblocks. */
- for (dp = first_diff; dp != NULL; dp = dp->df_next)
+ for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next)
if (lnum <= dp->df_lnum[idx] + dp->df_count[idx])
break;
if (dp == NULL || lnum < dp->df_lnum[idx])
* count, check if the lines are identical. */
cmp = FALSE;
for (i = 0; i < DB_COUNT; ++i)
- if (i != idx && diffbuf[i] != NULL)
+ if (i != idx && curtab->tp_diffbuf[i] != NULL)
{
if (dp->df_count[i] == 0)
zero = TRUE;
/* Compare all lines. If they are equal the lines were inserted
* in some buffers, deleted in others, but not changed. */
for (i = 0; i < DB_COUNT; ++i)
- if (i != idx && diffbuf[i] != NULL && dp->df_count[i] != 0)
+ if (i != idx && curtab->tp_diffbuf[i] != NULL && dp->df_count[i] != 0)
if (!diff_equal_entry(dp, idx, i))
return -1;
}
* 0 when this buf had the max count. */
maxcount = 0;
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] != NULL && dp->df_count[i] > maxcount)
+ if (curtab->tp_diffbuf[i] != NULL && dp->df_count[i] > maxcount)
maxcount = dp->df_count[i];
return maxcount - dp->df_count[idx];
}
if (dp->df_count[idx1] != dp->df_count[idx2])
return FALSE;
- if (diff_check_sanity(dp) == FAIL)
+ if (diff_check_sanity(curtab, dp) == FAIL)
return FALSE;
for (i = 0; i < dp->df_count[idx1]; ++i)
{
- line = vim_strsave(ml_get_buf(diffbuf[idx1],
+ line = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx1],
dp->df_lnum[idx1] + i, FALSE));
if (line == NULL)
return FALSE;
- cmp = diff_cmp(line, ml_get_buf(diffbuf[idx2],
+ cmp = diff_cmp(line, ml_get_buf(curtab->tp_diffbuf[idx2],
dp->df_lnum[idx2] + i, FALSE));
vim_free(line);
if (cmp != 0)
if (idx == DB_COUNT)
return; /* safety check */
- if (diff_invalid)
+ if (curtab->tp_diff_invalid)
ex_diffupdate(NULL); /* update after a big change */
towin->w_topfill = 0;
/* search for a change that includes "lnum" in the list of diffblocks. */
- for (dp = first_diff; dp != NULL; dp = dp->df_next)
+ for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next)
if (lnum <= dp->df_lnum[idx] + dp->df_count[idx])
break;
if (dp == NULL)
char_u *p;
int diff_context_new = 6;
int diff_flags_new = 0;
+ tabpage_T *tp;
p = p_dip;
while (*p != NUL)
/* If "icase" or "iwhite" was added or removed, need to update the diff. */
if (diff_flags != diff_flags_new)
- diff_invalid = TRUE;
+ for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
+ tp->tp_diff_invalid = TRUE;
diff_flags = diff_flags_new;
diff_context = diff_context_new;
return FALSE;
/* search for a change that includes "lnum" in the list of diffblocks. */
- for (dp = first_diff; dp != NULL; dp = dp->df_next)
+ for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next)
if (lnum <= dp->df_lnum[idx] + dp->df_count[idx])
break;
- if (dp == NULL || diff_check_sanity(dp) == FAIL)
+ if (dp == NULL || diff_check_sanity(curtab, dp) == FAIL)
return FALSE;
off = lnum - dp->df_lnum[idx];
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] != NULL && i != idx)
+ if (curtab->tp_diffbuf[i] != NULL && i != idx)
{
/* Skip lines that are not in the other change (filler lines). */
if (off >= dp->df_count[i])
continue;
added = FALSE;
- line_new = ml_get_buf(diffbuf[i], dp->df_lnum[i] + off, FALSE);
+ line_new = ml_get_buf(curtab->tp_diffbuf[i], dp->df_lnum[i] + off, FALSE);
/* Search for start of difference */
for (si = 0; line_org[si] != NUL && line_org[si] == line_new[si]; )
for (i = 0; i < DB_COUNT; ++i)
{
- if (diffbuf[i] == wp->w_buffer)
+ if (curtab->tp_diffbuf[i] == wp->w_buffer)
idx = i;
- else if (diffbuf[i] != NULL)
+ else if (curtab->tp_diffbuf[i] != NULL)
other = TRUE;
}
if (idx == -1 || !other)
return FALSE;
- if (diff_invalid)
+ if (curtab->tp_diff_invalid)
ex_diffupdate(NULL); /* update after a big change */
/* Return if there are no diff blocks. All lines will be folded. */
- if (first_diff == NULL)
+ if (curtab->tp_first_diff == NULL)
return TRUE;
- for (dp = first_diff; dp != NULL; dp = dp->df_next)
+ for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next)
{
/* If this change is below the line there can't be any further match. */
if (dp->df_lnum[idx] - diff_context > lnum)
{
/* No argument: Find the other buffer in the list of diff buffers. */
for (idx_other = 0; idx_other < DB_COUNT; ++idx_other)
- if (diffbuf[idx_other] != curbuf
- && diffbuf[idx_other] != NULL
+ if (curtab->tp_diffbuf[idx_other] != curbuf
+ && curtab->tp_diffbuf[idx_other] != NULL
&& (eap->cmdidx != CMD_diffput
- || diffbuf[idx_other]->b_p_ma))
+ || curtab->tp_diffbuf[idx_other]->b_p_ma))
break;
if (idx_other == DB_COUNT)
{
/* Check that there isn't a third buffer in the list */
for (i = idx_other + 1; i < DB_COUNT; ++i)
- if (diffbuf[i] != curbuf
- && diffbuf[i] != NULL
- && (eap->cmdidx != CMD_diffput || diffbuf[i]->b_p_ma))
+ if (curtab->tp_diffbuf[i] != curbuf
+ && curtab->tp_diffbuf[i] != NULL
+ && (eap->cmdidx != CMD_diffput || curtab->tp_diffbuf[i]->b_p_ma))
{
EMSG(_("E101: More than two buffers in diff mode, don't know which one to use"));
return;
/* Need to make the other buffer the current buffer to be able to make
* changes in it. */
/* set curwin/curbuf to buf and save a few things */
- aucmd_prepbuf(&aco, diffbuf[idx_other]);
+ aucmd_prepbuf(&aco, curtab->tp_diffbuf[idx_other]);
}
dprev = NULL;
- for (dp = first_diff; dp != NULL; )
+ for (dp = curtab->tp_first_diff; dp != NULL; )
{
if (dp->df_lnum[idx_cur] > eap->line2 + off)
break; /* past the range that was specified */
linenr_T nr;
nr = dp->df_lnum[idx_from] + start_skip + i;
- if (nr > diffbuf[idx_from]->b_ml.ml_line_count)
+ if (nr > curtab->tp_diffbuf[idx_from]->b_ml.ml_line_count)
break;
- p = vim_strsave(ml_get_buf(diffbuf[idx_from], nr, FALSE));
+ p = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx_from], nr, FALSE));
if (p != NULL)
{
ml_append(lnum + i - 1, p, 0, FALSE);
/* Check if there are any other buffers and if the diff is
* equal in them. */
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] != NULL && i != idx_from && i != idx_to
+ if (curtab->tp_diffbuf[i] != NULL && i != idx_from && i != idx_to
&& !diff_equal_entry(dp, idx_from, i))
break;
if (i == DB_COUNT)
dfree = dp;
dp = dp->df_next;
if (dprev == NULL)
- first_diff = dp;
+ curtab->tp_first_diff = dp;
else
dprev->df_next = dp;
}
for (wp = firstwin; wp != NULL; wp = wp->w_next)
for (i = 0; i < DB_COUNT; ++i)
- if (diffbuf[i] == wp->w_buffer && i != skip_idx)
+ if (curtab->tp_diffbuf[i] == wp->w_buffer && i != skip_idx)
foldUpdate(wp, dp->df_lnum[i],
dp->df_lnum[i] + dp->df_count[i]);
}
diff_mode_buf(buf)
buf_T *buf;
{
- return diff_buf_idx(buf) != DB_COUNT;
+ tabpage_T *tp;
+
+ for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
+ if (diff_buf_idx_tp(buf, tp) != DB_COUNT)
+ return TRUE;
+ return FALSE;
}
/*
diff_T *dp;
idx = diff_buf_idx(curbuf);
- if (idx == DB_COUNT || first_diff == NULL)
+ if (idx == DB_COUNT || curtab->tp_first_diff == NULL)
return FAIL;
- if (diff_invalid)
+ if (curtab->tp_diff_invalid)
ex_diffupdate(NULL); /* update after a big change */
- if (first_diff == NULL) /* no diffs today */
+ if (curtab->tp_first_diff == NULL) /* no diffs today */
return FAIL;
while (--count >= 0)
{
/* Check if already before first diff. */
- if (dir == BACKWARD && lnum <= first_diff->df_lnum[idx])
+ if (dir == BACKWARD && lnum <= curtab->tp_first_diff->df_lnum[idx])
break;
- for (dp = first_diff; ; dp = dp->df_next)
+ for (dp = curtab->tp_first_diff; ; dp = dp->df_next)
{
if (dp == NULL)
break;
if (idx == DB_COUNT) /* safety check */
return (linenr_T)0;
- if (diff_invalid)
+ if (curtab->tp_diff_invalid)
ex_diffupdate(NULL); /* update after a big change */
/* search for a change that includes "lnum" in the list of diffblocks. */
- for (dp = first_diff; dp != NULL; dp = dp->df_next)
+ for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next)
if (lnum <= dp->df_lnum[idx] + dp->df_count[idx])
break;
static void win_rotate __ARGS((int, int));
static void win_totop __ARGS((int size, int flags));
static void win_equal_rec __ARGS((win_T *next_curwin, int current, frame_T *topfr, int dir, int col, int row, int width, int height));
+static int last_window __ARGS((void));
static win_T *win_free_mem __ARGS((win_T *win, int *dirp, tabpage_T *tp));
static win_T *winframe_remove __ARGS((win_T *win, int *dirp, tabpage_T *tp));
static frame_T *win_altframe __ARGS((win_T *win, tabpage_T *tp));
#endif
static int win_alloc_firstwin __ARGS((void));
#if defined(FEAT_WINDOWS) || defined(PROTO)
-static tabpage_T *current_tabpage __ARGS((void));
+static tabpage_T *alloc_tabpage __ARGS((void));
+static void free_tabpage __ARGS((tabpage_T *tp));
static void leave_tabpage __ARGS((tabpage_T *tp));
static void enter_tabpage __ARGS((tabpage_T *tp, buf_T *old_curbuf));
static void frame_fix_height __ARGS((win_T *wp));
for (tp = first_tabpage; tp != NULL; tp = nexttp)
{
nexttp = tp->tp_next;
- if (tp->tp_topframe != topframe)
+ if (tp != curtab)
for (wp = tp->tp_firstwin; wp != NULL; wp = wp->w_next)
if (wp->w_buffer == buf)
{
/*
* Return TRUE if the current window is the only window that exists.
- * Returns FALSE if there is a window in another tab page.
+ * Returns FALSE if there is a window, possibly in another tab page.
*/
- int
+ static int
last_window()
{
return (lastwin == firstwin && first_tabpage->tp_next == NULL);
tabpage_T *tp;
tabpage_T *atp = alt_tabpage();
- for (tp = first_tabpage; tp->tp_topframe != topframe; tp = tp->tp_next)
+ for (tp = first_tabpage; tp != curtab; tp = tp->tp_next)
ptp = tp;
if (tp == NULL)
{
first_tabpage = tp->tp_next;
else
ptp->tp_next = tp->tp_next;
- vim_free(tp);
+ free_tabpage(tp);
/* We don't do the window resizing stuff, let enter_tabpage() take
* care of entering a window in another tab page. */
* current tab page. */
for (ptp = first_tabpage; ptp != NULL && ptp != tp; ptp = ptp->tp_next)
;
- if (ptp == NULL || tp->tp_topframe == topframe)
+ if (ptp == NULL || tp == curtab)
return;
/* Autocommands may have closed the window already. */
static tabpage_T *
alt_tabpage()
{
- tabpage_T *tp = current_tabpage();
+ tabpage_T *tp;
- if (tp != NULL)
- {
- /* Use the next tab page if it exists. */
- if (tp->tp_next != NULL)
- return tp->tp_next;
-
- /* Find the previous tab page. */
- for (tp = first_tabpage; tp->tp_next != NULL; tp = tp->tp_next)
- if (tp->tp_next == current_tabpage())
- return tp;
- }
+ /* Use the next tab page if it exists. */
+ if (curtab->tp_next != NULL)
+ return curtab->tp_next;
+
+ /* Find the previous tab page. */
+ for (tp = first_tabpage; tp->tp_next != NULL; tp = tp->tp_next)
+ if (tp->tp_next == curtab)
+ return tp;
return first_tabpage;
}
return FAIL;
#ifdef FEAT_WINDOWS
- first_tabpage = (tabpage_T *)alloc((unsigned)sizeof(tabpage_T));
+ first_tabpage = alloc_tabpage();
if (first_tabpage == NULL)
return FAIL;
first_tabpage->tp_topframe = topframe;
- first_tabpage->tp_next = NULL;
+ curtab = first_tabpage;
#endif
return OK;
}
}
#if defined(FEAT_WINDOWS) || defined(PROTO)
+
+/*
+ * Allocate a new tabpage_T and init the values.
+ * Returns NULL when out of memory.
+ */
+ static tabpage_T *
+alloc_tabpage()
+{
+ tabpage_T *tp;
+
+ tp = (tabpage_T *)alloc_clear((unsigned)sizeof(tabpage_T));
+ if (tp != NULL)
+ {
+# ifdef FEAT_DIFF
+ tp->tp_diff_invalid = TRUE;
+# endif
+ }
+ return tp;
+}
+
+ static void
+free_tabpage(tp)
+ tabpage_T *tp;
+{
+# ifdef FEAT_DIFF
+ diff_clear(tp);
+# endif
+ vim_free(tp);
+}
+
/*
* Create a new Tab page with one empty window.
* Put it just after the current Tab page.
int
win_new_tabpage()
{
- tabpage_T *tp;
+ tabpage_T *tp = curtab;
tabpage_T *newtp;
- newtp = (tabpage_T *)alloc((unsigned)sizeof(tabpage_T));
+ newtp = alloc_tabpage();
if (newtp == NULL)
return FAIL;
- tp = current_tabpage();
-
/* Remember the current windows in this Tab page. */
- leave_tabpage(tp);
+ leave_tabpage(curtab);
+ curtab = newtp;
/* Create a new empty window. */
if (win_alloc_firstwin() == OK)
prevwin = tp->tp_prevwin;
firstwin = tp->tp_firstwin;
lastwin = tp->tp_lastwin;
+ curtab = tp;
return FAIL;
}
/*
- * Return a pointer to the current tab page.
+ * Create up to "maxcount" tabpages with empty windows.
+ * Returns the number of resulting tab pages.
*/
- static tabpage_T *
-current_tabpage()
+ int
+make_tabpages(maxcount)
+ int maxcount;
{
- tabpage_T *tp;
+ int count = maxcount;
+ int todo;
- for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
- if (tp->tp_topframe == topframe)
+ /* Limit to 10 tabs. */
+ if (count > 10)
+ count = 10;
+
+#ifdef FEAT_AUTOCMD
+ /*
+ * Don't execute autocommands while creating the tab pages. Must do that
+ * when putting the buffers in the windows.
+ */
+ ++autocmd_block;
+#endif
+
+ for (todo = count - 1; todo > 0; --todo)
+ if (win_new_tabpage() == FAIL)
break;
- if (tp == NULL)
- EMSG2(_(e_intern2), "current_tabpage()");
- return tp;
+
+#ifdef FEAT_AUTOCMD
+ --autocmd_block;
+#endif
+
+ /* return actual number of tab pages */
+ return (count - todo);
}
/*
{
int old_off = tp->tp_firstwin->w_winrow;
+ curtab = tp;
firstwin = tp->tp_firstwin;
lastwin = tp->tp_lastwin;
topframe = tp->tp_topframe;
last_status(FALSE); /* status line may appear or disappear */
(void)win_comp_pos(); /* recompute w_winrow for all windows */
+ must_redraw = CLEAR; /* need to redraw everything */
+#ifdef FEAT_DIFF
+ diff_need_scrollbind = TRUE;
+#endif
/* The tabpage line may have appeared or disappeared, may need to resize
* the frames for that. When the Vim window was resized need to update
if (tp->tp_old_Rows != Rows || old_off != firstwin->w_winrow)
shell_new_rows();
#ifdef FEAT_VERTSPLIT
- if (tp->tp_old_Columns != Columns)
+ if (tp->tp_old_Columns != Columns && starting == 0)
shell_new_columns(); /* update window widths */
#endif
goto_tabpage(n)
int n;
{
- tabpage_T *otp = current_tabpage();
+ tabpage_T *otp = curtab;
tabpage_T *tp;
int i;
maketitle();
#endif
curwin->w_redr_status = TRUE;
- redraw_tabpage = TRUE;
+ redraw_tabline = TRUE;
if (restart_edit)
redraw_later(VALID); /* causes status line redraw */
}
/*
- * Return TRUE if there is only one window, not counting a help or preview
- * window, unless it is the current window.
+ * Return TRUE if there is only one window (in the current tab page), not
+ * counting a help or preview window, unless it is the current window.
*/
int
only_one_window()
projects / vim / commitdiff