/* ELLE - Copyright 1982, 1984, 1987 by Ken Harrenstien, SRI International
 *	This software is quasi-public; it may be used freely with
 *	like software, but may NOT be sold or made part of licensed
 *	products without permission of the author.
 */
/*	EEFED - ED-type functions
 */
#include "elle.h"

/*
 * ED_INSERT -- Insert character given as argument.
 */

ed_insert(c)
int c;
{	register SBBUF *sb;

	sb = (SBBUF *) cur_buf;		/* For a little speed */
	sb_putc(sb,c);		/* Insert the char */
	cur_dot++;		/* Advance dot */
	buf_tmod((chroff)-1);	/* Mark buffer modified, for redisplay etc. */
				/* Perhaps later use specialized routine? */
}

ed_insn(ch, cnt)
int ch, cnt;
{	register int i;
	if((i = cnt) > 0)
		do { ed_insert(ch);
		  } while(--i);
}

ed_crins()
{
#if FX_EOLMODE
	if (eolcrlf(cur_buf))	/* If EOL is made of CR-LF */
		ed_insert(CR);	/* then first insert CR, then drop down to */
#endif
	ed_insert(LF);		/* Insert LF */
}


ed_sins (s)			       /* insert this string */
register char *s;
{	register c;
	while (c = *s++)
		ed_insert (c);
}

ed_nsins (s, i)		/* Insert string of N chars */
register char *s;
register int i;
{	if(i > 0)
		do { ed_insert(*s++); } while(--i);
}

/* ED_INDTO(col) - Indent to specified column.
**	Finds current cursor position, and inserts tabs and spaces
** so cursor ends up at column goal.  Does nothing if already at or past
** specified column.
*/

ed_indto(goal)
register int goal;
{	register int ng;

	ng = goal & ~07;		/* Get distance to tab stop */
	ed_insn(TAB, ((ng - (d_curind() & ~07)) >> 3));
	ed_insn(SP, goal-ng);
}

/* Oddball routine - Set cur_dot to actual I/O location and
 * tell display that cursor probably moved.  This is not really a
 * function of itself; it provides support for real functions.
 */
ed_setcur()
{	e_setcur();	/* Set cur_dot */
	redp(RD_MOVE);	/* Alert redisplay to check cursor loc */
}

/* Go to given dot */
ed_go (dot)
chroff dot;
{	e_go(dot);
	ed_setcur();
}

/* Go to given offset from current location */
ed_goff(off)
chroff off;
{	e_goff(off);
	ed_setcur();
}

/* Go to given INTEGER offset from current location */
ed_igoff(ioff)
int ioff;
{	e_igoff(ioff);
	ed_setcur();
}

/* Reset (delete all of) Buffer
 * Should buffer be marked modified or not? Currently isn't.
 */
ed_reset()
{	if(e_blen() == 0)
		return;		/* Already empty */
	e_reset();
	cur_dot = 0;
	cur_win->w_topldot = 0;	/* Is this necessary? */
#if IMAGEN
	redp(RD_WINRES|RD_REDO);
#else
	redp(RD_WINRES);	/* This window needs complete update */
#endif /*-IMAGEN*/

/*	buf_mod(); */		/* Mark modified ?? */
/*	mark_p = 0; */		/* Say no mark set ?? */
}

ed_deln(off)
chroff off;
{	chroff dot;
	dot = e_dot();
	e_goff(off);	
	ed_delete(e_dot(), dot);
}

/* ED_DELETE(dot1,dot2) -  Delete all characters between the two
 *	positions indicated by dot1 and dot2.  Their order does not
 *	matter; cur_dot and mark_dot are updated as necessary.
 */
ed_delete(dot1,dot2)
chroff dot1,dot2;
{	chroff tmpdot, savdot;

	if(dot1 > dot2)
	  {	tmpdot = dot1;
		dot1 = dot2;
		dot2 = tmpdot;
	  }
	e_go(dot1);
	tmpdot = dot2-dot1;
	sb_deln((SBBUF *)cur_buf,tmpdot);

	savdot = cur_dot;		/* Save cur_dot value */
	cur_dot = dot1;			/* so can set up for */
	buf_tmod((chroff)0);		/* call to update disp-change vars */
	cur_dot = savdot;

	if(cur_dot >= dot2)
		cur_dot -= tmpdot;
	else if(cur_dot > dot1)
		cur_dot = dot1;
	if(mark_dot >= dot2)
		mark_dot -= tmpdot;
	else if(mark_dot > dot1)
		mark_dot = dot1;
	e_gocur();
}

/* ED_KILL(dot1,dot2) - Kill (save and delete) text between two places in
 *	the buffer.
 * We assume we are deleting from dot1 to dot2, thus if dot1 > dot2
 * then backwards deletion is implied, and the saved text is prefixed
 * (instead of appended) to any previously killed text.
 */
ed_kill(dot1,dot2)
chroff dot1,dot2;
{	register SBSTR *sd, *sdo;
	SBSTR *e_copyn();

	e_go(dot1);
	sd = e_copyn(dot2-dot1);
	if(sd == 0) return;
	if(last_cmd == KILLCMD && (sdo = kill_ring[kill_ptr]))
	  {	if(dot1 > dot2)	/* Prefix new killed stuff onto old stuff */
		  {	sbs_app(sd,sdo);
			kill_ring[kill_ptr] = sd;
		  }
		else		/* Append new stuff to old stuff */
			sbs_app(sdo,sd);
	  }
	else kill_push(sd);
	ed_delete(dot1,dot2);
}

kill_push(sdp)
SBSTR *sdp;
{	register SBSTR *sd;

	if(++kill_ptr >= KILL_LEN) kill_ptr = 0;
	if(sd = kill_ring[kill_ptr])
		sbs_del(sd);
	kill_ring[kill_ptr] = sdp;
}


#define isupper(c) (('A' <= c) && (c <= 'Z'))
#define islower(c) (('a' <= c) && (c <= 'z'))
#define toupper(c) (c + ('A' - 'a'))
#define tolower(c) (c + ('a' - 'A'))

#if FX_UCWORD||FX_LCWORD||FX_UCIWORD||FX_UCREG||FX_LCREG

/* ED_CASE(dot1,dot2,downp) - Change the case within a region.
 *	downp = 0 for uppercase, 1 for lowercase, 2 for capitalize.
 */
ed_case(dot1, dot2, downp)
chroff dot1, dot2;
int downp;
{	chroff dcnt;
	register int c, a, z;
	int modflg;

	modflg = 0;
	if((dcnt = dot2 - dot1) < 0)
	  {	dcnt = dot1;
		dot1 = dot2;
		dot2 = dcnt;
		dcnt -= dot1;
	  }
	e_go(dot1);

	if(downp==2)
	  {	a = 0;	/* 0 looking for wd, 1 in word */
		while(--dcnt >= 0)
		  {	if(delimp(c = e_getc()))	/* Char in wd? */
			  {	a = 0;			/* No */
				continue;
			  }
			 if(a)		/* If already inside word */
			  {	if(isupper(c))
					c = tolower(c);
				else continue;
			  }
			else	/* If encountered start of word */
			  {	a = 1;
				if(islower(c))
					c = toupper(c);
				else continue;
			  }
			e_backc();
			e_ovwc(c);
			modflg++;
		  }
		goto casdon;
	  }
	if(downp==0)
	  {	a = 'a';		/* Convert to lower case */
		z = 'z';
		downp = -040;
	  }
	else
	  {	a = 'A';		/* Convert to upper case */
		z = 'Z';
		downp = 040;
	  }
	while(--dcnt >= 0)
	  {	if(a <= (c = e_getc()) && c <= z)
		  {	e_backc();
			e_ovwc(c+downp);
			modflg++;
		  }
	  }

casdon:	dot2 = cur_dot;			/* Save dot */
	e_setcur();			/* Set up for modification range chk*/
	if(modflg)
		buf_tmat(dot1);		/* Stuff munged from there to here */
	ed_go(dot2);
}
#endif /* any ed_case caller */


/* UPCASE(c) - Return upper-case version of character */
upcase(ch)
int ch;
{	register int c;
	c = ch&0177;
	return(islower(c) ? toupper(c) : c);
}