OpenGrok

/*	$NetBSD: vs_relative.c,v 1.5 2018/06/03 08:08:37 rin Exp $ */
/*-
 * Copyright (c) 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 1993, 1994, 1995, 1996
 *	Keith Bostic.  All rights reserved.
 *
 * See the LICENSE file for redistribution information.
 */

#include "config.h"

#include <sys/cdefs.h>
#if 0
#ifndef lint
static const char sccsid[] = "Id: vs_relative.c,v 10.18 2001/07/08 13:02:48 skimo Exp  (Berkeley) Date: 2001/07/08 13:02:48 ";
#endif /* not lint */
#else
__RCSID("$NetBSD: vs_relative.c,v 1.5 2018/06/03 08:08:37 rin Exp $");
#endif

#include <sys/types.h>
#include <sys/queue.h>
#include <sys/time.h>

#include <bitstring.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>

#include "../common/common.h"
#include "vi.h"

/*
 * vs_column --
 *	Return the logical column of the cursor in the line.
 *
 * PUBLIC: int vs_column __P((SCR *, size_t *));
 */
int
vs_column(SCR *sp, size_t *colp)
{
	VI_PRIVATE *vip;

	vip = VIP(sp);

	*colp = (O_ISSET(sp, O_LEFTRIGHT) ?
	    vip->sc_smap->coff : (vip->sc_smap->soff - 1) * sp->cols) +
	    vip->sc_col - (O_ISSET(sp, O_NUMBER) ? O_NUMBER_LENGTH : 0);
	return (0);
}

/*
 * vs_screens --
 *	Return the screens necessary to display the line, or if specified,
 *	the physical character column within the line, including space
 *	required for the O_NUMBER and O_LIST options.
 *
 * PUBLIC: size_t vs_screens __P((SCR *, db_recno_t, size_t *));
 */
size_t
vs_screens(SCR *sp, db_recno_t lno, size_t *cnop)
{
	size_t cols, screens;

	/* Left-right screens are simple, it's always 1. */
	if (O_ISSET(sp, O_LEFTRIGHT))
		return (1);

	/*
	 * Check for a cached value.  We maintain a cache because, if the
	 * line is large, this routine gets called repeatedly.  One other
	 * hack, lots of time the cursor is on column one, which is an easy
	 * one.
	 */
	if (cnop == NULL) {
		if (VIP(sp)->ss_lno == lno)
			return (VIP(sp)->ss_screens);
	} else if (*cnop == 0)
		return (1);

	/* Figure out how many columns the line/column needs. */
	cols = vs_columns(sp, NULL, lno, cnop, NULL);

	screens = (cols / sp->cols + (cols % sp->cols ? 1 : 0));
	if (screens == 0)
		screens = 1;

	/* Cache the value. */
	if (cnop == NULL) {
		VIP(sp)->ss_lno = lno;
		VIP(sp)->ss_screens = screens;
	}
	return (screens);
}

/*
 * vs_columns --
 *	Return the screen columns necessary to display the line, or,
 *	if specified, the physical character column within the line.
 *
 * PUBLIC: size_t vs_columns __P((SCR *, CHAR_T *, db_recno_t, size_t *, size_t *));
 */
size_t
vs_columns(SCR *sp, CHAR_T *lp, db_recno_t lno, size_t *cnop, size_t *diffp)
{
	size_t chlen, cno, curoff, last = 0, len, scno;
	int ch, leftright, listset;
	CHAR_T *p;

	/*
	 * Initialize the screen offset.
	 */
	scno = 0;

	/* Leading number if O_NUMBER option set. */
	if (O_ISSET(sp, O_NUMBER))
		scno += O_NUMBER_LENGTH;

	/* Need the line to go any further. */
	if (lp == NULL) {
		(void)db_get(sp, lno, 0, &lp, &len);
		if (len == 0)
			goto done;
	}

	/* Missing or empty lines are easy. */
	if (lp == NULL) {
done:		if (diffp != NULL)		/* XXX */
			*diffp = 0;
		return scno;
	}

	/* Store away the values of the list and leftright edit options. */
	listset = O_ISSET(sp, O_LIST);
	leftright = O_ISSET(sp, O_LEFTRIGHT);

	/*
	 * Initialize the pointer into the buffer and current offset.
	 */
	p = lp;
	curoff = 0;

	/* Macro to return the display length of any signal character. */
#define	CHLEN(val) (ch = *(UCHAR_T *)p++) == '\t' &&			\
	    !listset ? TAB_OFF(val) : KEY_COL(sp, ch);

	/*
	 * If folding screens (the historic vi screen format), past the end
	 * of the current screen, and the character was a tab, reset the
	 * current screen column to 0, and the total screen columns to the
	 * last column of the screen.  Otherwise, display the rest of the
	 * character in the next screen.
	 */
#define	TAB_RESET {							\
	curoff += chlen;						\
	if (!leftright && curoff >= sp->cols) {				\
		if (ch == '\t') {					\
			curoff = 0;					\
			scno -= scno % sp->cols;			\
		} else							\
			curoff -= sp->cols;				\
	}								\
}
	if (cnop == NULL) {
		while (len > 0) {
			ch = (UCHAR_T)*p;

			/* singlebyte case */
			if (!INTISWIDE(ch)) {
				chlen = CHLEN(curoff);
				last = scno;
				scno += chlen;
				len--;
				/* p will be modified in CHLEN() */
				TAB_RESET;
				continue;
			}

			/* multibyte case */
			chlen = WIDE_COL(sp, ch);
			last = scno;
			scno += chlen;
			len--;
			p++;

			/*
			 * If multi-width char crosses the end-of-screen,
			 * put it on the next line.
			 */
			curoff += chlen;
			if (!leftright && curoff >= sp->cols) {
				if (curoff == sp->cols)
					curoff = 0;
				else {
					scno -= scno % sp->cols;
					scno += chlen;
					curoff = chlen;
				}
			}
		}
	} else {
		for (cno = *cnop;; --cno) {
			ch = (UCHAR_T)*p;

			/* singlebyte case */
			if (!INTISWIDE(ch)) {
				chlen = CHLEN(curoff);
				last = scno;
				scno += chlen;
				/* p will be modified in CHLEN() */
				TAB_RESET;
				if (cno == 0)
					break;
				continue;
			}

			/* multibyte case */
			chlen = WIDE_COL(sp, ch);
			last = scno;
			scno += chlen;
			p++;

			/*
			 * If multi-width char crosses the end-of-screen,
			 * put it on the next line.
			 */
			curoff += chlen;
			if (!leftright && curoff >= sp->cols) {
				if (curoff == sp->cols)
					curoff = 0;
				else {
					scno -= scno % sp->cols;
					scno += chlen;
					curoff = chlen;
				}
			}

			if (cno == 0)
				break;
		}
	}

	/* Add the trailing '$' if the O_LIST option set. */
	if (listset && cnop == NULL)
		scno += KEY_LEN(sp, '$');

	/*
	 * The text input screen code needs to know how much additional
	 * room the last two characters required, so that it can handle
	 * tab character displays correctly.
	 */
	if (diffp != NULL)
		*diffp = scno - last;
	return (scno);
}

/*
 * vs_rcm --
 *	Return the physical column from the line that will display a
 *	character closest to the currently most attractive character
 *	position (which is stored as a screen column).
 *
 * PUBLIC: size_t vs_rcm __P((SCR *, db_recno_t, int));
 */
size_t
vs_rcm(SCR *sp, db_recno_t lno, int islast)
{
	size_t len;

	/* Last character is easy, and common. */
	if (islast) {
		if (db_get(sp, lno, 0, NULL, &len) || len == 0)
			return (0);
		return (len - 1);
	}

	/* First character is easy, and common. */
	if (sp->rcm == 0)
		return (0);

	return (vs_colpos(sp, lno, sp->rcm));
}

/*
 * vs_colpos --
 *	Return the physical column from the line that will display a
 *	character closest to the specified screen column.
 *
 * PUBLIC: size_t vs_colpos __P((SCR *, db_recno_t, size_t));
 */
size_t
vs_colpos(SCR *sp, db_recno_t lno, size_t cno)
{
	size_t chlen, curoff, len, llen, off, scno;
	int ch = 0, leftright, listset;
	CHAR_T *lp, *p;

	/* Need the line to go any further. */
	(void)db_get(sp, lno, 0, &lp, &llen);

	/* Missing or empty lines are easy. */
	if (lp == NULL || llen == 0)
		return (0);

	/* Store away the values of the list and leftright edit options. */
	listset = O_ISSET(sp, O_LIST);
	leftright = O_ISSET(sp, O_LEFTRIGHT);

	/* Discard screen (logical) lines. */
	off = cno / sp->cols;
	cno %= sp->cols;
	for (scno = 0, p = lp, len = llen; off--;) {
		while (len && scno < sp->cols) {
			ch = (UCHAR_T)*p;
			if (ch == '\t' && !listset) {
				scno += TAB_OFF(scno);
				len--;
				p++;
				continue;
			}

			chlen = KEY_COL(sp, ch);
			if (!INTISWIDE(ch) || scno + chlen < sp->cols) {
				/*
				 * Singlebyte char can be displayed across
				 * the end-of-screen.
				 * If a multi-width char fits into this line,
				 * put it here.
				 */
				scno += chlen;
				len--;
				p++;
			} else if (leftright) {
				/*
				 * Side-scrolling screen is similar to
				 * singlebyte case.
				 */
				scno += chlen;
				len--;
				p++;
			} else {
				/*
				 * If multi-width char crosses the
				 * end-of-screen, put it on the next line.
				 *
				 * We must adjust ch to the last char of the
				 * line.
				 */
				scno = sp->cols;
			}
		}

		/*
		 * If reached the end of the physical line, return the last
		 * physical character in the line.
		 */
		if (len == 0)
			return (llen - 1);

		/*
		 * If folding screens (the historic vi screen format), past
		 * the end of the current screen, and the character was a tab,
		 * reset the current screen column to 0.  Otherwise, the rest
		 * of the character is displayed in the next screen.
		 */
		if (leftright && ch == '\t')
			scno = 0;
		else
			scno -= sp->cols;
	}

	/* Step through the line until reach the right character or EOL. */
	for (curoff = scno; len--;) {
		chlen = CHLEN(curoff);

		/*
		 * If we've reached the specific character, there are three
		 * cases.
		 *
		 * 1: scno == cno, i.e. the current character ends at the
		 *    screen character we care about.
		 *	a: off < llen - 1, i.e. not the last character in
		 *	   the line, return the offset of the next character.
		 *	b: else return the offset of the last character.
		 * 2: scno != cno, i.e. this character overruns the character
		 *    we care about, return the offset of this character.
		 */
		if ((scno += chlen) >= cno) {
			off = p - lp;
			return (scno == cno ?
			    (off < llen - 1 ? off : llen - 1) : off - 1);
		}

		TAB_RESET;
	}

	/* No such character; return the start of the last character. */
	return (llen - 1);
}