/*	$OpenBSD: vs_line.c,v 1.16 2016/05/27 09:18:12 martijn Exp $	*/

/*-

 * Copyright (c) 1993, 1994

 *	The Regents of the University of California.  All rights reserved.

 * Copyright (c) 1992, 1993, 1994, 1995, 1996

 *	Keith Bostic.  All rights reserved.

 *

 * See the LICENSE file for redistribution information.

 */

#include "config.h"

#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"

#ifdef VISIBLE_TAB_CHARS

#define	TABCH	'-'

#else

#define	TABCH	' '

#endif

/*

 * vs_line --

 *	Update one line on the screen.

 *

 * PUBLIC: int vs_line(SCR *, SMAP *, size_t *, size_t *);

 */

int

vs_line(SCR *sp, SMAP *smp, size_t *yp, size_t *xp)

{

	CHAR_T *kp;

	GS *gp;

	SMAP *tsmp;

	size_t scno, skip_cols, skip_screens;

	int ch = 0, dne, is_cached, is_partial, is_tab, no_draw;

	int list_tab, list_dollar;

#if defined(DEBUG) && 0

	TRACE(sp, "vs_line: row %u: line: %u off: %u\n",

	    smp - HMAP, smp->lno, smp->off);

#endif

	/*

	 * If ex modifies the screen after ex output is already on the screen,

	 * don't touch it -- we'll get scrolling wrong, at best.

	 */

	no_draw = 0;

	/*

	 * Assume that, if the cache entry for the line is filled in, the

	 * line is already on the screen, and all we need to do is return

	 * the cursor position.  If the calling routine doesn't need the

	 * cursor position, we can just return.

	 */

	/*

	 * A nasty side effect of this routine is that it returns the screen

	 * position for the "current" character.  Not pretty, but this is the

	 * only routine that really knows what's out there.

	 *

	 * Move to the line.  This routine can be called by vs_sm_position(),

	 * which uses it to fill in the cache entry so it can figure out what

	 * the real contents of the screen are.  Because of this, we have to

	 * return to whereever we started from.

	 */

	/* Get the line. */

	/*

	 * Special case if we're printing the info/mode line.  Skip printing

	 * the leading number, as well as other minor setup.  The only time

	 * this code paints the mode line is when the user is entering text

	 * for a ":" command, so we can put the code here instead of dealing

	 * with the empty line logic below.  This is a kludge, but it's pretty

	 * much confined to this module.

	 *

	 * Set the number of columns for this screen.

	 * Set the number of chars or screens to skip until a character is to

	 * be displayed.

	 */

		skip_screens = 0;

	}

	else {

		list_dollar = list_tab;

		/*

		 * If O_NUMBER is set, the line doesn't exist and it's line

		 * number 1, i.e., an empty file, display the line number.

		 *

		 * If O_NUMBER is set, the line exists and the first character

		 * on the screen is the first character in the line, display

		 * the line number.

		 *

		 * !!!

		 * If O_NUMBER set, decrement the number of columns in the

		 * first screen.  DO NOT CHANGE THIS -- IT'S RIGHT!  The

		 * rest of the code expects this to reflect the number of

		 * columns in the first screen, regardless of the number of

		 * columns we're going to skip.

		 */

					nlen = sizeof(cbuf) - 1;

			}

		}

	}

	/*

	 * Special case non-existent lines and the first line of an empty

	 * file.  In both cases, the cursor position is 0, but corrected

	 * as necessary for the O_NUMBER field, if it was displayed.

	 */

		/* Fill in the cursor. */

		}

		/* If the line is on the screen, quit. */

			goto ret1;

		/* Set line cache information. */

		/*

		 * Lots of special cases for empty lines, but they only apply

		 * if we're displaying the first screen of the line.

		 */

						ch = '$';

					}

				} else {

					ch = '~';

				}

			} else

				}

		}

	}

	/*

	 * If we just wrote this or a previous line, we cached the starting

	 * and ending positions of that line.  The way it works is we keep

	 * information about the lines displayed in the SMAP.  If we're

	 * painting the screen in the forward direction, this saves us from

	 * reformatting the physical line for every line on the screen.  This

	 * wins big on binary files with 10K lines.

	 *

	 * Test for the first screen of the line, then the current screen line,

	 * then the line behind us, then do the hard work.  Note, it doesn't

	 * do us any good to have a line in front of us -- it would be really

	 * hard to try and figure out tabs in the reverse direction, i.e. how

	 * many spaces a tab takes up in the reverse direction depends on

	 * what characters preceded it.

	 *

	 * Test for the first screen of the line.

	 */

	}

	/* Test to see if we've seen this exact line before. */

		/* Set cols_per_screen to 2nd and later line length. */

		goto display;

	}

	/* Test to see if we saw an earlier part of this line before. */

			offset_in_line = tsmp->c_eboff;

			offset_in_char = 0;

		}

		/* Put starting info for this line in the cache. */

		/* Set cols_per_screen to 2nd and later line length. */

		goto display;

	}

	scno = 0;

	offset_in_line = 0;

	offset_in_char = 0;

	/* Do it the hard way, for leftright scrolling screens. */

				break;

		}

		/* Set cols_per_screen to 2nd and later line length. */

		/* Put starting info for this line in the cache. */

		}

	}

	/* Do it the hard way, for historic line-folding screens. */

	else {

				continue;

			/* Set cols_per_screen to 2nd and later line length. */

			/*

			 * If crossed the last skipped screen boundary, start

			 * displaying the characters.

			 */

				break;

		}

		/* Put starting info for this line in the cache. */

		}

	}

display:

	/*

	 * Set the number of characters to skip before reaching the cursor

	 * character.  Offset by 1 and use 0 as a flag value.  Vs_line is

	 * called repeatedly with a valid pointer to a cursor position.

	 * Don't fill anything in unless it's the right line and the right

	 * character, and the right part of the character...

	 */

		cno_cnt = 0;

		/* If the line is on the screen, quit. */

			goto ret1;

	} else

	/* This is the loop that actually displays characters. */

			is_tab = 1;

			is_tab = 0;

		}

		/*

		 * Only display up to the right-hand column.  Set a flag if

		 * the entire character wasn't displayed for use in setting

		 * the cursor.  If reached the end of the line, set the cache

		 * info for the screen.  Don't worry about there not being

		 * characters to display on the next screen, its lno/off won't

		 * match up in that case.

		 */

				scno = cols_per_screen;

			}

			/* Terminate the loop. */

		}

		/*

		 * If the caller wants the cursor value, and this was the

		 * cursor character, set the value.  There are two ways to

		 * put the cursor on a character -- if it's normal display

		 * mode, it goes on the last column of the character.  If

		 * it's input mode, it goes on the first.  In normal mode,

		 * set the cursor only if the entire character was displayed.

		 */

				else

			} else

			/* If the line is on the screen, quit. */

				goto ret1;

		}

		/* If the line is on the screen, don't display anything. */

			continue;

#define	FLUSH(gp, sp, cbp, cbuf) do {					\

	*(cbp) = '\0';							\

	(void)(gp)->scr_addstr((sp), (cbuf), (cbp) - (cbuf));		\

	(cbp) = (cbuf);							\

} while (0)

		/*

		 * Display the character.  We do tab expansion here because

		 * the screen interface doesn't have any way to set the tab

		 * length.  Note, it's theoretically possible for chlen to

		 * be larger than cbuf, if the user set a impossibly large

		 * tabstop.

		 */

			}

		else {

		}

	}

		/* If we didn't paint the whole line, update the cache. */

		/*

		 * If not the info/mode line, and O_LIST set, and at the

		 * end of the line, and the line ended on this screen,

		 * add a trailing $.

		 */

		}

		/* If still didn't paint the whole line, clear the rest. */

	}

	/* Flush any buffered characters. */

}

/*

 * vs_number --

 *	Repaint the numbers on all the lines.

 *

 * PUBLIC: int vs_number(SCR *);

 */

int

vs_number(SCR *sp)

{

	GS *gp;

	SMAP *smp;

	int exist;

	/* No reason to do anything if we're in input mode on the info line. */

	/*

	 * Try and avoid getting the last line in the file, by getting the

	 * line after the last line in the screen -- if it exists, we know

	 * we have to to number all the lines in the screen.  Get the one

	 * after the last instead of the last, so that the info line doesn't

	 * fool us.  (The problem is that file_lline will lie, and tell us

	 * that the info line is the last line in the file.) If that test

	 * fails, we have to check each line for existence.

	 */

		/* Numbers are only displayed for the first screen line. */

				continue;

		} else

				continue;

		/*

		 * The first line of an empty file gets numbered, otherwise

		 * number any existing line.

		 */

			break;

			len = sizeof(nbuf) - 1;

	}

}