/*	$OpenBSD: v_itxt.c,v 1.8 2014/11/12 04:28:41 bentley Exp $	*/

/*-

 * Copyright (c) 1992, 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 <ctype.h>

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

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

#include "vi.h"

/*

 * !!!

 * Repeated input in the historic vi is mostly wrong and this isn't very

 * backward compatible.  For example, if the user entered "3Aab\ncd" in

 * the historic vi, the "ab" was repeated 3 times, and the "\ncd" was then

 * appended to the result.  There was also a hack which I don't remember

 * right now, where "3o" would open 3 lines and then let the user fill them

 * in, to make screen movements on 300 baud modems more tolerable.  I don't

 * think it's going to be missed.

 *

 * !!!

 * There's a problem with the way that we do logging for change commands with

 * implied motions (e.g. A, I, O, cc, etc.).  Since the main vi loop logs the

 * starting cursor position before the change command "moves" the cursor, the

 * cursor position to which we return on undo will be where the user entered

 * the change command, not the start of the change.  Several of the following

 * routines re-log the cursor to make this work correctly.  Historic vi tried

 * to do the same thing, and mostly got it right.  (The only spectacular way

 * it fails is if the user entered 'o' from anywhere but the last character of

 * the line, the undo returned the cursor to the start of the line.  If the

 * user was on the last character of the line, the cursor returned to that

 * position.)  We also check for mapped keys waiting, i.e. if we're in the

 * middle of a map, don't bother logging the cursor.

 */

#define	LOG_CORRECT {							\

	if (!MAPPED_KEYS_WAITING(sp))					\

		(void)log_cursor(sp);					\

}

static u_int32_t set_txt_std(SCR *, VICMD *, u_int32_t);

/*

 * v_iA -- [count]A

 *	Append text to the end of the line.

 *

 * PUBLIC: int v_iA(SCR *, VICMD *);

 */

int

v_iA(SCR *sp, VICMD *vp)

{

}

/*

 * v_ia -- [count]a

 *	   [count]A

 *	Append text to the cursor position.

 *

 * PUBLIC: int v_ia(SCR *, VICMD *);

 */

int

v_ia(SCR *sp, VICMD *vp)

{

	u_int32_t flags;

	/* Move the cursor one column to the right and repaint the screen. */

	} else

}

/*

 * v_iI -- [count]I

 *	Insert text at the first nonblank.

 *

 * PUBLIC: int v_iI(SCR *, VICMD *);

 */

int

v_iI(SCR *sp, VICMD *vp)

{

}

/*

 * v_ii -- [count]i

 *	   [count]I

 *	Insert text at the cursor position.

 *

 * PUBLIC: int v_ii(SCR *, VICMD *);

 */

int

v_ii(SCR *sp, VICMD *vp)

{

	u_int32_t flags;

	}

}

enum which { o_cmd, O_cmd };

static int io(SCR *, VICMD *, enum which);

/*

 * v_iO -- [count]O

 *	Insert text above this line.

 *

 * PUBLIC: int v_iO(SCR *, VICMD *);

 */

int

v_iO(SCR *sp, VICMD *vp)

{

}

/*

 * v_io -- [count]o

 *	Insert text after this line.

 *

 * PUBLIC: int v_io(SCR *, VICMD *);

 */

int

v_io(SCR *sp, VICMD *vp)

{

}

static int

io(SCR *sp, VICMD *vp, enum which cmd)

{

	u_int32_t flags;

			goto insert;

		ai_line = OOBLNO;

		}

	}

}

/*

 * v_change -- [buffer][count]c[count]motion

 *	       [buffer][count]C

 *	       [buffer][count]S

 *	Change command.

 *

 * PUBLIC: int v_change(SCR *, VICMD *);

 */

int

v_change(SCR *sp, VICMD *vp)

{

	u_int32_t flags;

	/*

	 * 'c' can be combined with motion commands that set the resulting

	 * cursor position, i.e. "cG".  Clear the VM_RCM flags and make the

	 * resulting cursor position stick, inserting text has its own rules

	 * for cursor positioning.

	 */

	/*

	 * Find out if the file is empty, it's easier to handle it as a

	 * special case.

	 */

	}

	/*

	 * Move the cursor to the start of the change.  Note, if autoindent

	 * is turned on, the cc command in line mode changes from the first

	 * *non-blank* character of the line, not the first character.  And,

	 * to make it just a bit more exciting, the initial space is handled

	 * as auto-indent characters.

	 */

		}

	}

	/*

	 * If not in line mode and changing within a single line, copy the

	 * text and overwrite it.

	 */

		/*

		 * !!!

		 * Historic practice, c did not cut into the numeric buffers,

		 * only the unnamed one.

		 */

		    &vp->m_start, &vp->m_stop, lmode))

	}

	/*

	 * It's trickier if in line mode or changing over multiple lines.  If

	 * we're in line mode delete all of the lines and insert a replacement

	 * line which the user edits.  If there was leading whitespace in the

	 * first line being changed, we copy it and use it as the replacement.

	 * If we're not in line mode, we delete the text and start inserting.

	 *

	 * !!!

	 * Copy the text.  Historic practice, c did not cut into the numeric

	 * buffers, only the unnamed one.

	 */

	    &vp->m_start, &vp->m_stop, lmode))

	/* If replacing entire lines and there's leading text. */

		/*

		 * Get a copy of the first line changed, and copy out the

		 * leading text.

		 */

		bp = NULL;

	/* Delete the text. */

	/* If replacing entire lines, insert a replacement line. */

	}

	/* Get the line we're editing. */

	}

	/* Check to see if we're appending to the line. */

}

/*

 * v_Replace -- [count]R

 *	Overwrite multiple characters.

 *

 * PUBLIC: int v_Replace(SCR *, VICMD *);

 */

int

v_Replace(SCR *sp, VICMD *vp)

{

	u_int32_t flags;

	}

}

/*

 * v_subst -- [buffer][count]s

 *	Substitute characters.

 *

 * PUBLIC: int v_subst(SCR *, VICMD *);

 */

int

v_subst(SCR *sp, VICMD *vp)

{

	u_int32_t flags;

	}

	    &vp->m_start, &vp->m_stop, 0))

}

/*

 * set_txt_std --

 *	Initialize text processing flags.

 */

static u_int32_t

set_txt_std(SCR *sp, VICMD *vp, u_int32_t flags)

{

	    TXT_ESCAPE | TXT_MAPINPUT | TXT_RECORD | TXT_RESOLVE);

	/*

	 * !!!

	 * Mapped keys were sometimes unaffected by the wrapmargin option

	 * in the historic 4BSD vi.  Consider the following commands, where

	 * each is executed on an empty line, in an 80 column screen, with

	 * the wrapmargin value set to 60.

	 *

	 *	aABC DEF <ESC>....

	 *	:map K aABC DEF ^V<ESC><CR>KKKKK

	 *	:map K 5aABC DEF ^V<ESC><CR>K

	 *

	 * The first and second commands are affected by wrapmargin.  The

	 * third is not.  (If the inserted text is itself longer than the

	 * wrapmargin value, i.e. if the "ABC DEF " string is replaced by

	 * something that's longer than 60 columns from the beginning of

	 * the line, the first two commands behave as before, but the third

	 * command gets fairly strange.)  The problem is that people wrote

	 * macros that depended on the third command NOT being affected by

	 * wrapmargin, as in this gem which centers lines:

	 *

	 *	map #c $mq81a ^V^[81^V^V|D`qld0:s/  / /g^V^M$p

	 *

	 * For compatibility reasons, we try and make it all work here.  I

	 * offer no hope that this is right, but it's probably pretty close.

	 *

	 * XXX

	 * Once I work my courage up, this is all gonna go away.  It's too

	 * evil to survive.

	 */

}