Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libedit/emacs.c	Lines:	0	158	0.0 %
Date:	2017-11-07	Branches:	0	86	0.0 %


/*	$OpenBSD: emacs.c,v 1.17 2016/05/06 13:12:52 schwarze Exp $	*/
/*	$NetBSD: emacs.c,v 1.35 2016/04/18 17:01:19 christos Exp $	*/

/*-
 * Copyright (c) 1992, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Christos Zoulas of Cornell University.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

/*
 * emacs.c: Emacs functions
 */
#include <ctype.h>

#include "el.h"
#include "emacs.h"
#include "fcns.h"

/* em_delete_or_list():
 *	Delete character under cursor or list completions if at end of line
 *	[^D]
 */
protected el_action_t
/*ARGSUSED*/
em_delete_or_list(EditLine *el, wint_t c)
{

	if (el->el_line.cursor == el->el_line.lastchar) {
					/* if I'm at the end */
		if (el->el_line.cursor == el->el_line.buffer) {
					/* and the beginning */
			terminal_writec(el, c);	/* then do an EOF */
			return CC_EOF;
		} else {
			/*
			 * Here we could list completions, but it is an
			 * error right now
			 */
			terminal_beep(el);
			return CC_ERROR;
		}
	} else {
		if (el->el_state.doingarg)
			c_delafter(el, el->el_state.argument);
		else
			c_delafter1(el);
		if (el->el_line.cursor > el->el_line.lastchar)
			el->el_line.cursor = el->el_line.lastchar;
				/* bounds check */
		return CC_REFRESH;
	}
}


/* em_delete_next_word():
 *	Cut from cursor to end of current word
 *	[M-d]
 */
protected el_action_t
/*ARGSUSED*/
em_delete_next_word(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *cp, *p, *kp;

	if (el->el_line.cursor == el->el_line.lastchar)
		return CC_ERROR;

	cp = c__next_word(el->el_line.cursor, el->el_line.lastchar,
	    el->el_state.argument, ce__isword);

	for (p = el->el_line.cursor, kp = el->el_chared.c_kill.buf; p < cp; p++)
				/* save the text */
		*kp++ = *p;
	el->el_chared.c_kill.last = kp;

	c_delafter(el, (int)(cp - el->el_line.cursor));	/* delete after dot */
	if (el->el_line.cursor > el->el_line.lastchar)
		el->el_line.cursor = el->el_line.lastchar;
				/* bounds check */
	return CC_REFRESH;
}


/* em_yank():
 *	Paste cut buffer at cursor position
 *	[^Y]
 */
protected el_action_t
/*ARGSUSED*/
em_yank(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *kp, *cp;

	if (el->el_chared.c_kill.last == el->el_chared.c_kill.buf)
		return CC_NORM;

	if (el->el_line.lastchar +
	    (el->el_chared.c_kill.last - el->el_chared.c_kill.buf) >=
	    el->el_line.limit)
		return CC_ERROR;

	el->el_chared.c_kill.mark = el->el_line.cursor;
	cp = el->el_line.cursor;

	/* open the space, */
	c_insert(el,
	    (int)(el->el_chared.c_kill.last - el->el_chared.c_kill.buf));
	/* copy the chars */
	for (kp = el->el_chared.c_kill.buf; kp < el->el_chared.c_kill.last; kp++)
		*cp++ = *kp;

	/* if an arg, cursor at beginning else cursor at end */
	if (el->el_state.argument == 1)
		el->el_line.cursor = cp;

	return CC_REFRESH;
}


/* em_kill_line():
 *	Cut the entire line and save in cut buffer
 *	[^U]
 */
protected el_action_t
/*ARGSUSED*/
em_kill_line(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *kp, *cp;

	cp = el->el_line.buffer;
	kp = el->el_chared.c_kill.buf;
	while (cp < el->el_line.lastchar)
		*kp++ = *cp++;	/* copy it */
	el->el_chared.c_kill.last = kp;
				/* zap! -- delete all of it */
	el->el_line.lastchar = el->el_line.buffer;
	el->el_line.cursor = el->el_line.buffer;
	return CC_REFRESH;
}


/* em_kill_region():
 *	Cut area between mark and cursor and save in cut buffer
 *	[^W]
 */
protected el_action_t
/*ARGSUSED*/
em_kill_region(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *kp, *cp;

	if (!el->el_chared.c_kill.mark)
		return CC_ERROR;

	if (el->el_chared.c_kill.mark > el->el_line.cursor) {
		cp = el->el_line.cursor;
		kp = el->el_chared.c_kill.buf;
		while (cp < el->el_chared.c_kill.mark)
			*kp++ = *cp++;	/* copy it */
		el->el_chared.c_kill.last = kp;
		c_delafter(el, (int)(cp - el->el_line.cursor));
	} else {		/* mark is before cursor */
		cp = el->el_chared.c_kill.mark;
		kp = el->el_chared.c_kill.buf;
		while (cp < el->el_line.cursor)
			*kp++ = *cp++;	/* copy it */
		el->el_chared.c_kill.last = kp;
		c_delbefore(el, (int)(cp - el->el_chared.c_kill.mark));
		el->el_line.cursor = el->el_chared.c_kill.mark;
	}
	return CC_REFRESH;
}


/* em_copy_region():
 *	Copy area between mark and cursor to cut buffer
 *	[M-W]
 */
protected el_action_t
/*ARGSUSED*/
em_copy_region(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *kp, *cp;

	if (!el->el_chared.c_kill.mark)
		return CC_ERROR;

	if (el->el_chared.c_kill.mark > el->el_line.cursor) {
		cp = el->el_line.cursor;
		kp = el->el_chared.c_kill.buf;
		while (cp < el->el_chared.c_kill.mark)
			*kp++ = *cp++;	/* copy it */
		el->el_chared.c_kill.last = kp;
	} else {
		cp = el->el_chared.c_kill.mark;
		kp = el->el_chared.c_kill.buf;
		while (cp < el->el_line.cursor)
			*kp++ = *cp++;	/* copy it */
		el->el_chared.c_kill.last = kp;
	}
	return CC_NORM;
}


/* em_gosmacs_transpose():
 *	Exchange the two characters before the cursor
 *	Gosling emacs transpose chars [^T]
 */
protected el_action_t
em_gosmacs_transpose(EditLine *el, wint_t c)
{

	if (el->el_line.cursor > &el->el_line.buffer[1]) {
		/* must have at least two chars entered */
		c = el->el_line.cursor[-2];
		el->el_line.cursor[-2] = el->el_line.cursor[-1];
		el->el_line.cursor[-1] = c;
		return CC_REFRESH;
	} else
		return CC_ERROR;
}


/* em_next_word():
 *	Move next to end of current word
 *	[M-f]
 */
protected el_action_t
/*ARGSUSED*/
em_next_word(EditLine *el, wint_t c __attribute__((__unused__)))
{
	if (el->el_line.cursor == el->el_line.lastchar)
		return CC_ERROR;

	el->el_line.cursor = c__next_word(el->el_line.cursor,
	    el->el_line.lastchar,
	    el->el_state.argument,
	    ce__isword);

	if (el->el_map.type == MAP_VI)
		if (el->el_chared.c_vcmd.action != NOP) {
			cv_delfini(el);
			return CC_REFRESH;
		}
	return CC_CURSOR;
}


/* em_upper_case():
 *	Uppercase the characters from cursor to end of current word
 *	[M-u]
 */
protected el_action_t
/*ARGSUSED*/
em_upper_case(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *cp, *ep;

	ep = c__next_word(el->el_line.cursor, el->el_line.lastchar,
	    el->el_state.argument, ce__isword);

	for (cp = el->el_line.cursor; cp < ep; cp++)
		if (iswlower(*cp))
			*cp = towupper(*cp);

	el->el_line.cursor = ep;
	if (el->el_line.cursor > el->el_line.lastchar)
		el->el_line.cursor = el->el_line.lastchar;
	return CC_REFRESH;
}


/* em_capitol_case():
 *	Capitalize the characters from cursor to end of current word
 *	[M-c]
 */
protected el_action_t
/*ARGSUSED*/
em_capitol_case(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *cp, *ep;

	ep = c__next_word(el->el_line.cursor, el->el_line.lastchar,
	    el->el_state.argument, ce__isword);

	for (cp = el->el_line.cursor; cp < ep; cp++) {
		if (iswalpha(*cp)) {
			if (iswlower(*cp))
				*cp = towupper(*cp);
			cp++;
			break;
		}
	}
	for (; cp < ep; cp++)
		if (iswupper(*cp))
			*cp = towlower(*cp);

	el->el_line.cursor = ep;
	if (el->el_line.cursor > el->el_line.lastchar)
		el->el_line.cursor = el->el_line.lastchar;
	return CC_REFRESH;
}


/* em_lower_case():
 *	Lowercase the characters from cursor to end of current word
 *	[M-l]
 */
protected el_action_t
/*ARGSUSED*/
em_lower_case(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *cp, *ep;

	ep = c__next_word(el->el_line.cursor, el->el_line.lastchar,
	    el->el_state.argument, ce__isword);

	for (cp = el->el_line.cursor; cp < ep; cp++)
		if (iswupper(*cp))
			*cp = towlower(*cp);

	el->el_line.cursor = ep;
	if (el->el_line.cursor > el->el_line.lastchar)
		el->el_line.cursor = el->el_line.lastchar;
	return CC_REFRESH;
}


/* em_set_mark():
 *	Set the mark at cursor
 *	[^@]
 */
protected el_action_t
/*ARGSUSED*/
em_set_mark(EditLine *el, wint_t c __attribute__((__unused__)))
{

	el->el_chared.c_kill.mark = el->el_line.cursor;
	return CC_NORM;
}


/* em_exchange_mark():
 *	Exchange the cursor and mark
 *	[^X^X]
 */
protected el_action_t
/*ARGSUSED*/
em_exchange_mark(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *cp;

	cp = el->el_line.cursor;
	el->el_line.cursor = el->el_chared.c_kill.mark;
	el->el_chared.c_kill.mark = cp;
	return CC_CURSOR;
}


/* em_universal_argument():
 *	Universal argument (argument times 4)
 *	[^U]
 */
protected el_action_t
/*ARGSUSED*/
em_universal_argument(EditLine *el, wint_t c __attribute__((__unused__)))
{				/* multiply current argument by 4 */

	if (el->el_state.argument > 1000000)
		return CC_ERROR;
	el->el_state.doingarg = 1;
	el->el_state.argument *= 4;
	return CC_ARGHACK;
}


/* em_meta_next():
 *	Add 8th bit to next character typed
 *	[<ESC>]
 */
protected el_action_t
/*ARGSUSED*/
em_meta_next(EditLine *el, wint_t c __attribute__((__unused__)))
{

	el->el_state.metanext = 1;
	return CC_ARGHACK;
}


/* em_toggle_overwrite():
 *	Switch from insert to overwrite mode or vice versa
 */
protected el_action_t
/*ARGSUSED*/
em_toggle_overwrite(EditLine *el, wint_t c __attribute__((__unused__)))
{

	el->el_state.inputmode = (el->el_state.inputmode == MODE_INSERT) ?
	    MODE_REPLACE : MODE_INSERT;
	return CC_NORM;
}


/* em_copy_prev_word():
 *	Copy current word to cursor
 */
protected el_action_t
/*ARGSUSED*/
em_copy_prev_word(EditLine *el, wint_t c __attribute__((__unused__)))
{
	wchar_t *cp, *oldc, *dp;

	if (el->el_line.cursor == el->el_line.buffer)
		return CC_ERROR;

	oldc = el->el_line.cursor;
	/* does a bounds check */
	cp = c__prev_word(el->el_line.cursor, el->el_line.buffer,
	    el->el_state.argument, ce__isword);

	c_insert(el, (int)(oldc - cp));
	for (dp = oldc; cp < oldc && dp < el->el_line.lastchar; cp++)
		*dp++ = *cp;

	el->el_line.cursor = dp;/* put cursor at end */

	return CC_REFRESH;
}


/* em_inc_search_next():
 *	Emacs incremental next search
 */
protected el_action_t
/*ARGSUSED*/
em_inc_search_next(EditLine *el, wint_t c __attribute__((__unused__)))
{

	el->el_search.patlen = 0;
	return ce_inc_search(el, ED_SEARCH_NEXT_HISTORY);
}


/* em_inc_search_prev():
 *	Emacs incremental reverse search
 */
protected el_action_t
/*ARGSUSED*/
em_inc_search_prev(EditLine *el, wint_t c __attribute__((__unused__)))
{

	el->el_search.patlen = 0;
	return ce_inc_search(el, ED_SEARCH_PREV_HISTORY);
}


/* em_delete_prev_char():
 *	Delete the character to the left of the cursor
 *	[^?]
 */
protected el_action_t
/*ARGSUSED*/
em_delete_prev_char(EditLine *el, wint_t c __attribute__((__unused__)))
{

	if (el->el_line.cursor <= el->el_line.buffer)
		return CC_ERROR;

	if (el->el_state.doingarg)
		c_delbefore(el, el->el_state.argument);
	else
		c_delbefore1(el);
	el->el_line.cursor -= el->el_state.argument;
	if (el->el_line.cursor < el->el_line.buffer)
		el->el_line.cursor = el->el_line.buffer;
	return CC_REFRESH;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: emacs.c,v 1.17 2016/05/06 13:12:52 schwarze Exp $ */
2			/* $NetBSD: emacs.c,v 1.35 2016/04/18 17:01:19 christos Exp $ */
3
4			/*-
5			* Copyright (c) 1992, 1993
6			* The Regents of the University of California. All rights reserved.
7			*
8			* This code is derived from software contributed to Berkeley by
9			* Christos Zoulas of Cornell University.
10			*
11			* Redistribution and use in source and binary forms, with or without
12			* modification, are permitted provided that the following conditions
13			* are met:
14			* 1. Redistributions of source code must retain the above copyright
15			* notice, this list of conditions and the following disclaimer.
16			* 2. Redistributions in binary form must reproduce the above copyright
17			* notice, this list of conditions and the following disclaimer in the
18			* documentation and/or other materials provided with the distribution.
19			* 3. Neither the name of the University nor the names of its contributors
20			* may be used to endorse or promote products derived from this software
21			* without specific prior written permission.
22			*
23			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33			* SUCH DAMAGE.
34			*/
35
36			#include "config.h"
37
38			/*
39			* emacs.c: Emacs functions
40			*/
41			#include <ctype.h>
42
43			#include "el.h"
44			#include "emacs.h"
45			#include "fcns.h"
46
47			/* em_delete_or_list():
48			* Delete character under cursor or list completions if at end of line
49			* [^D]
50			*/
51			protected el_action_t
52			/ARGSUSED/
53			em_delete_or_list(EditLine *el, wint_t c)
54			{
55
56			if (el->el_line.cursor == el->el_line.lastchar) {
57			/* if I'm at the end */
58			if (el->el_line.cursor == el->el_line.buffer) {
59			/* and the beginning */
60			terminal_writec(el, c); /* then do an EOF */
61			return CC_EOF;
62			} else {
63			/*
64			* Here we could list completions, but it is an
65			* error right now
66			*/
67			terminal_beep(el);
68			return CC_ERROR;
69			}
70			} else {
71			if (el->el_state.doingarg)
72			c_delafter(el, el->el_state.argument);
73			else
74			c_delafter1(el);
75			if (el->el_line.cursor > el->el_line.lastchar)
76			el->el_line.cursor = el->el_line.lastchar;
77			/* bounds check */
78			return CC_REFRESH;
79			}
80			}
81
82
83			/* em_delete_next_word():
84			* Cut from cursor to end of current word
85			* [M-d]
86			*/
87			protected el_action_t
88			/ARGSUSED/
89			em_delete_next_word(EditLine *el, wint_t c __attribute__((__unused__)))
90			{
91			wchar_t cp, p, *kp;
92
93			if (el->el_line.cursor == el->el_line.lastchar)
94			return CC_ERROR;
95
96			cp = c__next_word(el->el_line.cursor, el->el_line.lastchar,
97			el->el_state.argument, ce__isword);
98
99			for (p = el->el_line.cursor, kp = el->el_chared.c_kill.buf; p < cp; p++)
100			/* save the text */
101			kp++ = p;
102			el->el_chared.c_kill.last = kp;
103
104			c_delafter(el, (int)(cp - el->el_line.cursor)); /* delete after dot */
105			if (el->el_line.cursor > el->el_line.lastchar)
106			el->el_line.cursor = el->el_line.lastchar;
107			/* bounds check */
108			return CC_REFRESH;
109			}
110
111
112			/* em_yank():
113			* Paste cut buffer at cursor position
114			* [^Y]
115			*/
116			protected el_action_t
117			/ARGSUSED/
118			em_yank(EditLine *el, wint_t c __attribute__((__unused__)))
119			{
120			wchar_t kp, cp;
121
122			if (el->el_chared.c_kill.last == el->el_chared.c_kill.buf)
123			return CC_NORM;
124
125			if (el->el_line.lastchar +
126			(el->el_chared.c_kill.last - el->el_chared.c_kill.buf) >=
127			el->el_line.limit)
128			return CC_ERROR;
129
130			el->el_chared.c_kill.mark = el->el_line.cursor;
131			cp = el->el_line.cursor;
132
133			/* open the space, */
134			c_insert(el,
135			(int)(el->el_chared.c_kill.last - el->el_chared.c_kill.buf));
136			/* copy the chars */
137			for (kp = el->el_chared.c_kill.buf; kp < el->el_chared.c_kill.last; kp++)
138			cp++ = kp;
139
140			/* if an arg, cursor at beginning else cursor at end */
141			if (el->el_state.argument == 1)
142			el->el_line.cursor = cp;
143
144			return CC_REFRESH;
145			}
146
147
148			/* em_kill_line():
149			* Cut the entire line and save in cut buffer
150			* [^U]
151			*/
152			protected el_action_t
153			/ARGSUSED/
154			em_kill_line(EditLine *el, wint_t c __attribute__((__unused__)))
155			{
156			wchar_t kp, cp;
157
158			cp = el->el_line.buffer;
159			kp = el->el_chared.c_kill.buf;
160			while (cp < el->el_line.lastchar)
161			kp++ = cp++; /* copy it */
162			el->el_chared.c_kill.last = kp;
163			/* zap! -- delete all of it */
164			el->el_line.lastchar = el->el_line.buffer;
165			el->el_line.cursor = el->el_line.buffer;
166			return CC_REFRESH;
167			}
168
169
170			/* em_kill_region():
171			* Cut area between mark and cursor and save in cut buffer
172			* [^W]
173			*/
174			protected el_action_t
175			/ARGSUSED/
176			em_kill_region(EditLine *el, wint_t c __attribute__((__unused__)))
177			{
178			wchar_t kp, cp;
179
180			if (!el->el_chared.c_kill.mark)
181			return CC_ERROR;
182
183			if (el->el_chared.c_kill.mark > el->el_line.cursor) {
184			cp = el->el_line.cursor;
185			kp = el->el_chared.c_kill.buf;
186			while (cp < el->el_chared.c_kill.mark)
187			kp++ = cp++; /* copy it */
188			el->el_chared.c_kill.last = kp;
189			c_delafter(el, (int)(cp - el->el_line.cursor));
190			} else { /* mark is before cursor */
191			cp = el->el_chared.c_kill.mark;
192			kp = el->el_chared.c_kill.buf;
193			while (cp < el->el_line.cursor)
194			kp++ = cp++; /* copy it */
195			el->el_chared.c_kill.last = kp;
196			c_delbefore(el, (int)(cp - el->el_chared.c_kill.mark));
197			el->el_line.cursor = el->el_chared.c_kill.mark;
198			}
199			return CC_REFRESH;
200			}
201
202
203			/* em_copy_region():
204			* Copy area between mark and cursor to cut buffer
205			* [M-W]
206			*/
207			protected el_action_t
208			/ARGSUSED/
209			em_copy_region(EditLine *el, wint_t c __attribute__((__unused__)))
210			{
211			wchar_t kp, cp;
212
213			if (!el->el_chared.c_kill.mark)
214			return CC_ERROR;
215
216			if (el->el_chared.c_kill.mark > el->el_line.cursor) {
217			cp = el->el_line.cursor;
218			kp = el->el_chared.c_kill.buf;
219			while (cp < el->el_chared.c_kill.mark)
220			kp++ = cp++; /* copy it */
221			el->el_chared.c_kill.last = kp;
222			} else {
223			cp = el->el_chared.c_kill.mark;
224			kp = el->el_chared.c_kill.buf;
225			while (cp < el->el_line.cursor)
226			kp++ = cp++; /* copy it */
227			el->el_chared.c_kill.last = kp;
228			}
229			return CC_NORM;
230			}
231
232
233			/* em_gosmacs_transpose():
234			* Exchange the two characters before the cursor
235			* Gosling emacs transpose chars [^T]
236			*/
237			protected el_action_t
238			em_gosmacs_transpose(EditLine *el, wint_t c)
239			{
240
241			if (el->el_line.cursor > &el->el_line.buffer[1]) {
242			/* must have at least two chars entered */
243			c = el->el_line.cursor[-2];
244			el->el_line.cursor[-2] = el->el_line.cursor[-1];
245			el->el_line.cursor[-1] = c;
246			return CC_REFRESH;
247			} else
248			return CC_ERROR;
249			}
250
251
252			/* em_next_word():
253			* Move next to end of current word
254			* [M-f]
255			*/
256			protected el_action_t
257			/ARGSUSED/
258			em_next_word(EditLine *el, wint_t c __attribute__((__unused__)))
259			{
260			if (el->el_line.cursor == el->el_line.lastchar)
261			return CC_ERROR;
262
263			el->el_line.cursor = c__next_word(el->el_line.cursor,
264			el->el_line.lastchar,
265			el->el_state.argument,
266			ce__isword);
267
268			if (el->el_map.type == MAP_VI)
269			if (el->el_chared.c_vcmd.action != NOP) {
270			cv_delfini(el);
271			return CC_REFRESH;
272			}
273			return CC_CURSOR;
274			}
275
276
277			/* em_upper_case():
278			* Uppercase the characters from cursor to end of current word
279			* [M-u]
280			*/
281			protected el_action_t
282			/ARGSUSED/
283			em_upper_case(EditLine *el, wint_t c __attribute__((__unused__)))
284			{
285			wchar_t cp, ep;
286
287			ep = c__next_word(el->el_line.cursor, el->el_line.lastchar,
288			el->el_state.argument, ce__isword);
289
290			for (cp = el->el_line.cursor; cp < ep; cp++)
291			if (iswlower(*cp))
292			cp = towupper(cp);
293
294			el->el_line.cursor = ep;
295			if (el->el_line.cursor > el->el_line.lastchar)
296			el->el_line.cursor = el->el_line.lastchar;
297			return CC_REFRESH;
298			}
299
300
301			/* em_capitol_case():
302			* Capitalize the characters from cursor to end of current word
303			* [M-c]
304			*/
305			protected el_action_t
306			/ARGSUSED/
307			em_capitol_case(EditLine *el, wint_t c __attribute__((__unused__)))
308			{
309			wchar_t cp, ep;
310
311			ep = c__next_word(el->el_line.cursor, el->el_line.lastchar,
312			el->el_state.argument, ce__isword);
313
314			for (cp = el->el_line.cursor; cp < ep; cp++) {
315			if (iswalpha(*cp)) {
316			if (iswlower(*cp))
317			cp = towupper(cp);
318			cp++;
319			break;
320			}
321			}
322			for (; cp < ep; cp++)
323			if (iswupper(*cp))
324			cp = towlower(cp);
325
326			el->el_line.cursor = ep;
327			if (el->el_line.cursor > el->el_line.lastchar)
328			el->el_line.cursor = el->el_line.lastchar;
329			return CC_REFRESH;
330			}
331
332
333			/* em_lower_case():
334			* Lowercase the characters from cursor to end of current word
335			* [M-l]
336			*/
337			protected el_action_t
338			/ARGSUSED/
339			em_lower_case(EditLine *el, wint_t c __attribute__((__unused__)))
340			{
341			wchar_t cp, ep;
342
343			ep = c__next_word(el->el_line.cursor, el->el_line.lastchar,
344			el->el_state.argument, ce__isword);
345
346			for (cp = el->el_line.cursor; cp < ep; cp++)
347			if (iswupper(*cp))
348			cp = towlower(cp);
349
350			el->el_line.cursor = ep;
351			if (el->el_line.cursor > el->el_line.lastchar)
352			el->el_line.cursor = el->el_line.lastchar;
353			return CC_REFRESH;
354			}
355
356
357			/* em_set_mark():
358			* Set the mark at cursor
359			* [^@]
360			*/
361			protected el_action_t
362			/ARGSUSED/
363			em_set_mark(EditLine *el, wint_t c __attribute__((__unused__)))
364			{
365
366			el->el_chared.c_kill.mark = el->el_line.cursor;
367			return CC_NORM;
368			}
369
370
371			/* em_exchange_mark():
372			* Exchange the cursor and mark
373			* [^X^X]
374			*/
375			protected el_action_t
376			/ARGSUSED/
377			em_exchange_mark(EditLine *el, wint_t c __attribute__((__unused__)))
378			{
379			wchar_t *cp;
380
381			cp = el->el_line.cursor;
382			el->el_line.cursor = el->el_chared.c_kill.mark;
383			el->el_chared.c_kill.mark = cp;
384			return CC_CURSOR;
385			}
386
387
388			/* em_universal_argument():
389			* Universal argument (argument times 4)
390			* [^U]
391			*/
392			protected el_action_t
393			/ARGSUSED/
394			em_universal_argument(EditLine *el, wint_t c __attribute__((__unused__)))
395			{ /* multiply current argument by 4 */
396
397			if (el->el_state.argument > 1000000)
398			return CC_ERROR;
399			el->el_state.doingarg = 1;
400			el->el_state.argument *= 4;
401			return CC_ARGHACK;
402			}
403
404
405			/* em_meta_next():
406			* Add 8th bit to next character typed
407			* [<ESC>]
408			*/
409			protected el_action_t
410			/ARGSUSED/
411			em_meta_next(EditLine *el, wint_t c __attribute__((__unused__)))
412			{
413
414			el->el_state.metanext = 1;
415			return CC_ARGHACK;
416			}
417
418
419			/* em_toggle_overwrite():
420			* Switch from insert to overwrite mode or vice versa
421			*/
422			protected el_action_t
423			/ARGSUSED/
424			em_toggle_overwrite(EditLine *el, wint_t c __attribute__((__unused__)))
425			{
426
427			el->el_state.inputmode = (el->el_state.inputmode == MODE_INSERT) ?
428			MODE_REPLACE : MODE_INSERT;
429			return CC_NORM;
430			}
431
432
433			/* em_copy_prev_word():
434			* Copy current word to cursor
435			*/
436			protected el_action_t
437			/ARGSUSED/
438			em_copy_prev_word(EditLine *el, wint_t c __attribute__((__unused__)))
439			{
440			wchar_t cp, oldc, *dp;
441
442			if (el->el_line.cursor == el->el_line.buffer)
443			return CC_ERROR;
444
445			oldc = el->el_line.cursor;
446			/* does a bounds check */
447			cp = c__prev_word(el->el_line.cursor, el->el_line.buffer,
448			el->el_state.argument, ce__isword);
449
450			c_insert(el, (int)(oldc - cp));
451			for (dp = oldc; cp < oldc && dp < el->el_line.lastchar; cp++)
452			dp++ = cp;
453
454			el->el_line.cursor = dp;/* put cursor at end */
455
456			return CC_REFRESH;
457			}
458
459
460			/* em_inc_search_next():
461			* Emacs incremental next search
462			*/
463			protected el_action_t
464			/ARGSUSED/
465			em_inc_search_next(EditLine *el, wint_t c __attribute__((__unused__)))
466			{
467
468			el->el_search.patlen = 0;
469			return ce_inc_search(el, ED_SEARCH_NEXT_HISTORY);
470			}
471
472
473			/* em_inc_search_prev():
474			* Emacs incremental reverse search
475			*/
476			protected el_action_t
477			/ARGSUSED/
478			em_inc_search_prev(EditLine *el, wint_t c __attribute__((__unused__)))
479			{
480
481			el->el_search.patlen = 0;
482			return ce_inc_search(el, ED_SEARCH_PREV_HISTORY);
483			}
484
485
486			/* em_delete_prev_char():
487			* Delete the character to the left of the cursor
488			* [^?]
489			*/
490			protected el_action_t
491			/ARGSUSED/
492			em_delete_prev_char(EditLine *el, wint_t c __attribute__((__unused__)))
493			{
494
495			if (el->el_line.cursor <= el->el_line.buffer)
496			return CC_ERROR;
497
498			if (el->el_state.doingarg)
499			c_delbefore(el, el->el_state.argument);
500			else
501			c_delbefore1(el);
502			el->el_line.cursor -= el->el_state.argument;
503			if (el->el_line.cursor < el->el_line.buffer)
504			el->el_line.cursor = el->el_line.buffer;
505			return CC_REFRESH;
506			}